@pikku/core 0.12.106 → 0.12.111

package/src/wirings/scheduler/scheduler-runner.test.ts

@@ -1,835 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  wireScheduler,
-  runScheduledTask,
-  getScheduledTasks,
-} from './scheduler-runner.js'
-import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import type { CoreScheduledTask } from './scheduler.types.js'
-import type { CoreUserSession } from '../../types/core.types.js'
-
-beforeEach(() => {
-  resetPikkuState()
-})
-
-const createMockLogger = () => {
-  const logs: Array<{ level: string; message: string; error?: any }> = []
-  return {
-    info: (msg: string) => logs.push({ level: 'info', message: msg }),
-    warn: (msg: string) => logs.push({ level: 'warn', message: msg }),
-    error: (msg: string, error?: any) =>
-      logs.push({ level: 'error', message: msg, error }),
-    debug: (msg: string) => logs.push({ level: 'debug', message: msg }),
-    getLogs: () => logs,
-  }
-}
-
-describe('wireScheduler', () => {
-  test('should successfully wire a scheduled task', () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'test-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncId: 'scheduler_test-task',
-      name: 'test-task',
-      schedule: '0 0 * * *',
-    }
-
-    wireScheduler(mockTask)
-
-    const tasks = pikkuState(null, 'scheduler', 'tasks')
-    assert.equal(tasks.has('test-task'), true)
-    assert.equal(tasks.get('test-task'), mockTask)
-  })
-
-  test('should skip when scheduled task metadata not found', () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'missing-meta-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-      },
-    }
-
-    wireScheduler(mockTask)
-
-    const tasks = pikkuState(null, 'scheduler', 'tasks')
-    assert.equal(tasks.has('missing-meta-task'), false)
-  })
-
-  test('should throw error when scheduled task already exists', () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'duplicate-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['duplicate-task'] = {
-      pikkuFuncId: 'scheduler_duplicate-task',
-      name: 'duplicate-task',
-      schedule: '0 0 * * *',
-    }
-
-    wireScheduler(mockTask)
-
-    assert.throws(
-      () => wireScheduler(mockTask),
-      (error: any) => {
-        assert.equal(
-          error.message,
-          'Scheduled task already exists: duplicate-task'
-        )
-        return true
-      }
-    )
-  })
-
-  test('should wire task with middleware and tags', () => {
-    const middleware = async (services: any, wire: any, next: any) => {
-      await next()
-    }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'task-with-middleware',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-        middleware: [middleware],
-        tags: ['admin'],
-      },
-      middleware: [middleware],
-      tags: ['scheduled'],
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['task-with-middleware'] = {
-      pikkuFuncId: 'scheduler_task-with-middleware',
-      name: 'task-with-middleware',
-      schedule: '0 0 * * *',
-    }
-
-    wireScheduler(mockTask)
-
-    const tasks = pikkuState(null, 'scheduler', 'tasks')
-    const task = tasks.get('task-with-middleware')
-    assert.equal(task?.middleware?.length, 1)
-    assert.deepEqual(task?.tags, ['scheduled'])
-  })
-})
-
-describe('runScheduledTask', () => {
-  test('should successfully run a scheduled task', async () => {
-    let taskExecuted = false
-
-    const mockTask: CoreScheduledTask = {
-      name: 'simple-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {
-          taskExecuted = true
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['simple-task'] = {
-      pikkuFuncId: 'scheduler_simple-task',
-      name: 'simple-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_simple-task'] = {
-      pikkuFuncId: 'scheduler_simple-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-    await runScheduledTask({
-      name: 'simple-task',
-    })
-
-    assert.equal(taskExecuted, true)
-
-    const logs = mockLogger.getLogs()
-    assert.equal(logs.length, 1)
-    assert.equal(logs[0].level, 'info')
-    assert(logs[0].message.includes('Running schedule task: simple-task'))
-  })
-
-  test('should run task with session', async () => {
-    let receivedSession: CoreUserSession | undefined
-
-    const mockTask: CoreScheduledTask = {
-      name: 'task-with-session',
-      schedule: '0 0 * * *',
-      func: {
-        func: async (services: any, data: any, wire: any) => {
-          receivedSession = await wire.getSession()
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['task-with-session'] = {
-      pikkuFuncId: 'scheduler_task-with-session',
-      name: 'task-with-session',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_task-with-session'] = {
-      pikkuFuncId: 'scheduler_task-with-session',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-    const session: CoreUserSession = { userId: 'user123' }
-
-    await runScheduledTask({
-      name: 'task-with-session',
-      session,
-    })
-
-    assert.deepEqual(receivedSession, session)
-  })
-
-  test('a task middleware can set the session the task runs as', async () => {
-    let frozenSession: CoreUserSession | undefined
-    const machineSession: CoreUserSession = {
-      userId: 'cron:machine-session-task',
-    }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'machine-session-task',
-      schedule: '0 0 * * *',
-      middleware: [
-        async (_services: any, wire: any, next: any) => {
-          wire.setSession(machineSession)
-          return next()
-        },
-      ] as any,
-      func: {
-        func: async (_services: any, _data: any, wire: any) => {
-          frozenSession = wire.session
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['machine-session-task'] = {
-      pikkuFuncId: 'scheduler_machine-session-task',
-      name: 'machine-session-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_machine-session-task'] = {
-      pikkuFuncId: 'scheduler_machine-session-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: createMockLogger(),
-    } as any)
-
-    await runScheduledTask({ name: 'machine-session-task' })
-
-    assert.deepEqual(frozenSession, machineSession)
-  })
-
-  test('a session-taking task does not warn that auth was disabled', async () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'identified-task',
-      schedule: '0 0 * * *',
-      middleware: [
-        async (_services: any, wire: any, next: any) => {
-          wire.setSession({ userId: 'cron:identified-task' })
-          return next()
-        },
-      ] as any,
-      func: {
-        func: async () => {},
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['identified-task'] = {
-      pikkuFuncId: 'scheduler_identified-task',
-      name: 'identified-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_identified-task'] = {
-      pikkuFuncId: 'scheduler_identified-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: false,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await runScheduledTask({ name: 'identified-task' })
-
-    assert.deepEqual(
-      mockLogger
-        .getLogs()
-        .filter(
-          (log) =>
-            log.level === 'warn' && /auth was explicitly disabled/.test(log.message)
-        ),
-      []
-    )
-  })
-
-  test('should throw ScheduledTaskNotFoundError when task not found', async () => {
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await assert.rejects(
-      async () => {
-        await runScheduledTask({
-          name: 'non-existent-task',
-        })
-      },
-      (error: any) => {
-        assert(error.message.includes('Scheduled task not found'))
-        return true
-      }
-    )
-  })
-
-  test('should throw ScheduledTaskNotFoundError when meta not found', async () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'task-without-meta',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'tasks').set('task-without-meta', mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await assert.rejects(
-      async () => {
-        await runScheduledTask({
-          name: 'task-without-meta',
-        })
-      },
-      (error: any) => {
-        assert(error.message.includes('Scheduled task meta not found'))
-        return true
-      }
-    )
-  })
-
-  test('should handle task.skip() by throwing ScheduledTaskSkippedError', async () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'skipped-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async (services: any, data: any, wire: any) => {
-          wire.scheduledTask.skip('Not ready yet')
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['skipped-task'] = {
-      pikkuFuncId: 'scheduler_skipped-task',
-      name: 'skipped-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_skipped-task'] = {
-      pikkuFuncId: 'scheduler_skipped-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await assert.rejects(
-      async () => {
-        await runScheduledTask({
-          name: 'skipped-task',
-        })
-      },
-      (error: any) => {
-        assert(
-          error.message.includes("Scheduled task 'skipped-task' was skipped")
-        )
-        assert(error.message.includes('Not ready yet'))
-        return true
-      }
-    )
-  })
-
-  test('should handle task.skip() without reason', async () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'skipped-task-no-reason',
-      schedule: '0 0 * * *',
-      func: {
-        func: async (services: any, data: any, wire: any) => {
-          wire.scheduledTask.skip()
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['skipped-task-no-reason'] = {
-      pikkuFuncId: 'scheduler_skipped-task-no-reason',
-      name: 'skipped-task-no-reason',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_skipped-task-no-reason'] = {
-      pikkuFuncId: 'scheduler_skipped-task-no-reason',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await assert.rejects(
-      async () => {
-        await runScheduledTask({
-          name: 'skipped-task-no-reason',
-        })
-      },
-      (error: any) => {
-        assert(
-          error.message.includes(
-            "Scheduled task 'skipped-task-no-reason' was skipped"
-          )
-        )
-        return true
-      }
-    )
-  })
-
-  test('should provide correct wire object to task', async () => {
-    let capturedWire: any
-
-    const mockTask: CoreScheduledTask = {
-      name: 'wire-task',
-      schedule: '*/5 * * * *',
-      func: {
-        func: async (services: any, data: any, wire: any) => {
-          capturedWire = wire
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['wire-task'] = {
-      pikkuFuncId: 'scheduler_wire-task',
-      name: 'wire-task',
-      schedule: '*/5 * * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_wire-task'] = {
-      pikkuFuncId: 'scheduler_wire-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await runScheduledTask({
-      name: 'wire-task',
-    })
-
-    assert.equal(capturedWire.scheduledTask.name, 'wire-task')
-    assert.equal(capturedWire.scheduledTask.schedule, '*/5 * * * *')
-    assert(capturedWire.scheduledTask.executionTime instanceof Date)
-    assert.equal(typeof capturedWire.scheduledTask.skip, 'function')
-  })
-
-  test('should call createWireServices when provided', async () => {
-    let createWireServicesCalled = false
-    const mockWireService = { custom: 'service' }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'session-services-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => undefined,
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['session-services-task'] = {
-      pikkuFuncId: 'scheduler_session-services-task',
-      name: 'session-services-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_session-services-task'] = {
-      pikkuFuncId: 'scheduler_session-services-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-    pikkuState(null, 'package', 'factories', {
-      createWireServices: async () => {
-        createWireServicesCalled = true
-        return mockWireService as any
-      },
-    } as any)
-
-    await runScheduledTask({
-      name: 'session-services-task',
-    })
-
-    assert.equal(createWireServicesCalled, true)
-  })
-
-  test('should clean up wire services in finally block', async () => {
-    let closeCalled = false
-    const mockWireService = {
-      custom: {
-        close: async () => {
-          closeCalled = true
-        },
-      },
-    }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'cleanup-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => undefined,
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['cleanup-task'] = {
-      pikkuFuncId: 'scheduler_cleanup-task',
-      name: 'cleanup-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_cleanup-task'] = {
-      pikkuFuncId: 'scheduler_cleanup-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-    pikkuState(null, 'package', 'factories', {
-      createWireServices: async () => mockWireService as any,
-    } as any)
-
-    await runScheduledTask({
-      name: 'cleanup-task',
-    })
-
-    assert.equal(closeCalled, true)
-  })
-
-  test('should clean up wire services even when task throws error', async () => {
-    let closeCalled = false
-    const mockWireService = {
-      custom: {
-        close: async () => {
-          closeCalled = true
-        },
-      },
-    }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'error-cleanup-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {
-          throw new Error('Task failed')
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['error-cleanup-task'] = {
-      pikkuFuncId: 'scheduler_error-cleanup-task',
-      name: 'error-cleanup-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_error-cleanup-task'] = {
-      pikkuFuncId: 'scheduler_error-cleanup-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-    pikkuState(null, 'package', 'factories', {
-      createWireServices: async () => mockWireService as any,
-    } as any)
-
-    await assert.rejects(async () => {
-      await runScheduledTask({
-        name: 'error-cleanup-task',
-      })
-    })
-
-    assert.equal(closeCalled, true)
-  })
-
-  test('should re-throw errors from task', async () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'error-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async (services: any, data: any, wire: any) => {
-          wire.scheduledTask.skip('Test skip')
-        },
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['error-task'] = {
-      pikkuFuncId: 'scheduler_error-task',
-      name: 'error-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_error-task'] = {
-      pikkuFuncId: 'scheduler_error-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await assert.rejects(async () => {
-      await runScheduledTask({
-        name: 'error-task',
-      })
-    })
-
-    const logs = mockLogger.getLogs()
-    const infoLogs = logs.filter((l) => l.level === 'info')
-    assert(infoLogs.length > 0)
-  })
-
-  test('should execute task with middleware', async () => {
-    const executionOrder: string[] = []
-
-    const middleware = async (services: any, wire: any, next: any) => {
-      executionOrder.push('middleware')
-      await next()
-    }
-
-    const mockTask: CoreScheduledTask = {
-      name: 'middleware-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {
-          executionOrder.push('task')
-        },
-        auth: false,
-      },
-      middleware: [middleware],
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['middleware-task'] = {
-      pikkuFuncId: 'scheduler_middleware-task',
-      name: 'middleware-task',
-      schedule: '0 0 * * *',
-    }
-    pikkuState(null, 'function', 'meta')['scheduler_middleware-task'] = {
-      pikkuFuncId: 'scheduler_middleware-task',
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: true,
-    }
-    wireScheduler(mockTask)
-
-    const mockLogger = createMockLogger()
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: mockLogger,
-    } as any)
-
-    await runScheduledTask({
-      name: 'middleware-task',
-    })
-
-    assert.deepEqual(executionOrder, ['middleware', 'task'])
-  })
-})
-
-describe('getScheduledTasks', () => {
-  test('should return the tasks map', () => {
-    const mockTask: CoreScheduledTask = {
-      name: 'test-task',
-      schedule: '0 0 * * *',
-      func: {
-        func: async () => {},
-        auth: false,
-      },
-    }
-
-    pikkuState(null, 'scheduler', 'meta')['test-task'] = {
-      pikkuFuncId: 'scheduler_test-task',
-      name: 'test-task',
-      schedule: '0 0 * * *',
-    }
-    wireScheduler(mockTask)
-
-    const tasks = getScheduledTasks()
-    assert.equal(tasks instanceof Map, true)
-    assert.equal(tasks.has('test-task'), true)
-  })
-
-  test('should return empty map when no tasks registered', () => {
-    const tasks = getScheduledTasks()
-    assert.equal(tasks instanceof Map, true)
-    assert.equal(tasks.size, 0)
-  })
-})
-
-/**
- * A cron has no caller to authenticate, so the only thing that can give it an
- * identity is its own wiring. These cover the mechanism the virtual-user
- * scaffold's `virtualUserPlatformSession` relies on: middleware on the task
- * sets the session, and the scope gate on the function it drives is enforced
- * against exactly that session — a tick with no identity, or one holding the
- * wrong scope, is refused the same way a person would be.
- */
-describe('a scheduled task authorizes on the session its own middleware sets', () => {
-  const wireGatedTask = (
-    name: string,
-    middleware?: Array<
-      (services: any, wire: any, next: any) => Promise<void> | void
-    >
-  ) => {
-    let seen: CoreUserSession | undefined
-    const task: CoreScheduledTask = {
-      name,
-      schedule: '0 * * * *',
-      func: {
-        func: async (_services: any, _data: any, wire: any) => {
-          seen = await wire.getSession()
-        },
-      } as any,
-      middleware,
-    }
-    pikkuState(null, 'scheduler', 'meta')[name] = {
-      pikkuFuncId: `scheduler_${name}`,
-      name,
-      schedule: '0 * * * *',
-    }
-    pikkuState(null, 'function', 'meta')[`scheduler_${name}`] = {
-      pikkuFuncId: `scheduler_${name}`,
-      inputSchemaName: null,
-      outputSchemaName: null,
-      sessionless: false,
-      scopes: ['virtualUser:run'],
-    }
-    wireScheduler(task)
-    pikkuState(null, 'package', 'singletonServices', {
-      logger: createMockLogger(),
-    } as any)
-    return () => seen
-  }
-
-  const settingSession = (session: CoreUserSession) => [
-    async (_services: any, wire: any, next: any) => {
-      await wire.setSession(session)
-      return next()
-    },
-  ]
-
-  test('is refused outright when nothing gives the tick an identity', async () => {
-    wireGatedTask('unidentified-tick')
-    await assert.rejects(
-      runScheduledTask({ name: 'unidentified-tick' }),
-      /Authentication required/
-    )
-  })
-
-  test('is refused when the identity it sets holds the wrong scope', async () => {
-    wireGatedTask(
-      'misscoped-tick',
-      settingSession({
-        userId: 'pikku-platform',
-        scopes: ['admin'],
-      } as CoreUserSession)
-    )
-    await assert.rejects(
-      runScheduledTask({ name: 'misscoped-tick' }),
-      /virtualUser:run/
-    )
-  })
-
-  test('runs as the platform user its middleware set', async () => {
-    const seen = wireGatedTask(
-      'platform-tick',
-      settingSession({
-        userId: 'pikku-platform',
-        scopes: ['virtualUser:run'],
-      } as CoreUserSession)
-    )
-    await runScheduledTask({ name: 'platform-tick' })
-    assert.equal(seen()?.userId, 'pikku-platform')
-  })
-})