@webiny/api-core-testing 0.0.0-unstable.0156a4c312

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-core-testing
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/handlers/AuthTriggerHandler.d.ts

@@ -0,0 +1,19 @@
+import { TestHttpEventHandler } from "@webiny/event-handler-core/features/testing";
+import type { EventContext, NextFunction } from "@webiny/event-handler-core";
+import type { IAuthenticationContext } from "@webiny/api-core/features/security/authentication/AuthenticationContext/index.js";
+import type { IIdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+/**
+ * Test-only decorator on the HTTP event handler: authenticates the `authorization` header and sets
+ * the resulting identity before the request is dispatched (mirrors the prod identity loader).
+ */
+declare class AuthTriggerHandlerImpl implements TestHttpEventHandler.Interface {
+    private authCtx;
+    private identityCtx;
+    private inner;
+    constructor(authCtx: IAuthenticationContext, identityCtx: IIdentityContext, inner: TestHttpEventHandler.Interface);
+    execute(ctx: EventContext, next: NextFunction): Promise<any>;
+}
+export declare const AuthTriggerHandler: typeof AuthTriggerHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IEventHandler<any, any>>;
+};
+export {};

package/handlers/AuthTriggerHandler.js

@@ -0,0 +1,27 @@
+import { TestHttpEventHandler } from "@webiny/event-handler-core/features/testing";
+import { AuthenticationContext } from "@webiny/api-core/features/security/authentication/AuthenticationContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+class AuthTriggerHandlerImpl {
+    constructor(authCtx, identityCtx, inner){
+        this.authCtx = authCtx;
+        this.identityCtx = identityCtx;
+        this.inner = inner;
+    }
+    async execute(ctx, next) {
+        const headers = ctx.event?.headers ?? {};
+        const token = headers["authorization"] ?? "";
+        const identity = await this.authCtx.authenticate(token);
+        this.identityCtx.setIdentity(identity);
+        return this.inner.execute(ctx, next);
+    }
+}
+const AuthTriggerHandler = TestHttpEventHandler.createDecorator({
+    decorator: AuthTriggerHandlerImpl,
+    dependencies: [
+        AuthenticationContext,
+        IdentityContext
+    ]
+});
+export { AuthTriggerHandler };
+
+//# sourceMappingURL=AuthTriggerHandler.js.map

package/handlers/AuthTriggerHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/AuthTriggerHandler.js","sources":["../../src/handlers/AuthTriggerHandler.ts"],"sourcesContent":["import { TestHttpEventHandler } from \"@webiny/event-handler-core/features/testing\";\nimport type { EventContext, NextFunction } from \"@webiny/event-handler-core\";\nimport { AuthenticationContext } from \"@webiny/api-core/features/security/authentication/AuthenticationContext/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { IAuthenticationContext } from \"@webiny/api-core/features/security/authentication/AuthenticationContext/index.js\";\nimport type { IIdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\n\n/**\n * Test-only decorator on the HTTP event handler: authenticates the `authorization` header and sets\n * the resulting identity before the request is dispatched (mirrors the prod identity loader).\n */\nclass AuthTriggerHandlerImpl implements TestHttpEventHandler.Interface {\n    constructor(\n        private authCtx: IAuthenticationContext,\n        private identityCtx: IIdentityContext,\n        private inner: TestHttpEventHandler.Interface\n    ) {}\n\n    async execute(ctx: EventContext, next: NextFunction): Promise<any> {\n        const headers = ctx.event?.headers ?? {};\n        const token = headers[\"authorization\"] ?? \"\";\n        const identity = await this.authCtx.authenticate(token);\n        this.identityCtx.setIdentity(identity);\n        return this.inner.execute(ctx, next);\n    }\n}\n\nexport const AuthTriggerHandler = TestHttpEventHandler.createDecorator({\n    decorator: AuthTriggerHandlerImpl,\n    dependencies: [AuthenticationContext, IdentityContext]\n});\n"],"names":["AuthTriggerHandlerImpl","authCtx","identityCtx","inner","ctx","next","headers","token","identity","AuthTriggerHandler","TestHttpEventHandler","AuthenticationContext","IdentityContext"],"mappings":";;;AAWA,MAAMA;IACF,YACYC,OAA+B,EAC/BC,WAA6B,EAC7BC,KAAqC,CAC/C;aAHUF,OAAO,GAAPA;aACAC,WAAW,GAAXA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QAAQC,GAAiB,EAAEC,IAAkB,EAAgB;QAC/D,MAAMC,UAAUF,IAAI,KAAK,EAAE,WAAW,CAAC;QACvC,MAAMG,QAAQD,OAAO,CAAC,gBAAgB,IAAI;QAC1C,MAAME,WAAW,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAACD;QACjD,IAAI,CAAC,WAAW,CAAC,WAAW,CAACC;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAACJ,KAAKC;IACnC;AACJ;AAEO,MAAMI,qBAAqBC,qBAAqB,eAAe,CAAC;IACnE,WAAWV;IACX,cAAc;QAACW;QAAuBC;KAAgB;AAC1D"}

package/handlers/RootTenantInitializer.d.ts

@@ -0,0 +1,17 @@
+import { TestHttpEventHandler } from "@webiny/event-handler-core/features/testing";
+import type { EventContext, NextFunction } from "@webiny/event-handler-core";
+import type { ITenantContext } from "@webiny/api-core/features/tenancy/TenantContext/abstractions.js";
+/**
+ * Test-only decorator on the HTTP event handler: sets the "root" tenant before the request is
+ * dispatched (mirrors the prod tenant loader).
+ */
+declare class RootTenantInitializerImpl implements TestHttpEventHandler.Interface {
+    private tenantCtx;
+    private inner;
+    constructor(tenantCtx: ITenantContext, inner: TestHttpEventHandler.Interface);
+    execute(ctx: EventContext, next: NextFunction): Promise<any>;
+}
+export declare const RootTenantInitializer: typeof RootTenantInitializerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IEventHandler<any, any>>;
+};
+export {};

package/handlers/RootTenantInitializer.js

@@ -0,0 +1,40 @@
+import { TestHttpEventHandler } from "@webiny/event-handler-core/features/testing";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/abstractions.js";
+class RootTenantInitializerImpl {
+    constructor(tenantCtx, inner){
+        this.tenantCtx = tenantCtx;
+        this.inner = inner;
+    }
+    async execute(ctx, next) {
+        this.tenantCtx.setTenant({
+            id: "root",
+            name: "Root",
+            description: "",
+            status: "enabled",
+            isInstalled: false,
+            settings: {
+                name: {
+                    full: "Root",
+                    slug: "root"
+                },
+                social: {},
+                favicon: {},
+                logo: {}
+            },
+            tags: [],
+            parent: null,
+            createdOn: new Date().toISOString(),
+            savedOn: new Date().toISOString()
+        });
+        return this.inner.execute(ctx, next);
+    }
+}
+const RootTenantInitializer = TestHttpEventHandler.createDecorator({
+    decorator: RootTenantInitializerImpl,
+    dependencies: [
+        TenantContext
+    ]
+});
+export { RootTenantInitializer };
+
+//# sourceMappingURL=RootTenantInitializer.js.map

package/handlers/RootTenantInitializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers/RootTenantInitializer.js","sources":["../../src/handlers/RootTenantInitializer.ts"],"sourcesContent":["import { TestHttpEventHandler } from \"@webiny/event-handler-core/features/testing\";\nimport type { EventContext, NextFunction } from \"@webiny/event-handler-core\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/abstractions.js\";\nimport type { ITenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/abstractions.js\";\n\n/**\n * Test-only decorator on the HTTP event handler: sets the \"root\" tenant before the request is\n * dispatched (mirrors the prod tenant loader).\n */\nclass RootTenantInitializerImpl implements TestHttpEventHandler.Interface {\n    constructor(\n        private tenantCtx: ITenantContext,\n        private inner: TestHttpEventHandler.Interface\n    ) {}\n\n    async execute(ctx: EventContext, next: NextFunction): Promise<any> {\n        this.tenantCtx.setTenant({\n            id: \"root\",\n            name: \"Root\",\n            description: \"\",\n            status: \"enabled\",\n            isInstalled: false,\n            settings: {\n                name: { full: \"Root\", slug: \"root\" },\n                social: {},\n                favicon: {},\n                logo: {}\n            } as any,\n            tags: [],\n            parent: null,\n            createdOn: new Date().toISOString(),\n            savedOn: new Date().toISOString()\n        });\n        return this.inner.execute(ctx, next);\n    }\n}\n\nexport const RootTenantInitializer = TestHttpEventHandler.createDecorator({\n    decorator: RootTenantInitializerImpl,\n    dependencies: [TenantContext]\n});\n"],"names":["RootTenantInitializerImpl","tenantCtx","inner","ctx","next","Date","RootTenantInitializer","TestHttpEventHandler","TenantContext"],"mappings":";;AASA,MAAMA;IACF,YACYC,SAAyB,EACzBC,KAAqC,CAC/C;aAFUD,SAAS,GAATA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QAAQC,GAAiB,EAAEC,IAAkB,EAAgB;QAC/D,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;YACrB,IAAI;YACJ,MAAM;YACN,aAAa;YACb,QAAQ;YACR,aAAa;YACb,UAAU;gBACN,MAAM;oBAAE,MAAM;oBAAQ,MAAM;gBAAO;gBACnC,QAAQ,CAAC;gBACT,SAAS,CAAC;gBACV,MAAM,CAAC;YACX;YACA,MAAM,EAAE;YACR,QAAQ;YACR,WAAW,IAAIC,OAAO,WAAW;YACjC,SAAS,IAAIA,OAAO,WAAW;QACnC;QACA,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAACF,KAAKC;IACnC;AACJ;AAEO,MAAME,wBAAwBC,qBAAqB,eAAe,CAAC;IACtE,WAAWP;IACX,cAAc;QAACQ;KAAc;AACjC"}

package/identity.d.ts

@@ -0,0 +1,7 @@
+import { type IdentityData } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { SecurityIdentity } from "@webiny/api-core/types/security.js";
+/**
+ * Build a test admin identity. Override any field via the partial:
+ * `createIdentity({ id: "abc", displayName: "Jane" })`.
+ */
+export declare const createIdentity: (identity?: Partial<IdentityData>) => SecurityIdentity;

package/identity.js

@@ -0,0 +1,10 @@
+import { AuthenticatedIdentity } from "@webiny/api-core/features/security/IdentityContext/index.js";
+const createIdentity = (identity = {})=>new AuthenticatedIdentity({
+        id: "12345678",
+        type: "admin",
+        displayName: "John Doe",
+        ...identity
+    });
+export { createIdentity };
+
+//# sourceMappingURL=identity.js.map

package/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sources":["../src/identity.ts"],"sourcesContent":["import {\n    AuthenticatedIdentity,\n    type IdentityData\n} from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { SecurityIdentity } from \"@webiny/api-core/types/security.js\";\n\n/**\n * Build a test admin identity. Override any field via the partial:\n * `createIdentity({ id: \"abc\", displayName: \"Jane\" })`.\n */\nexport const createIdentity = (identity: Partial<IdentityData> = {}): SecurityIdentity => {\n    return new AuthenticatedIdentity({\n        id: \"12345678\",\n        type: \"admin\",\n        displayName: \"John Doe\",\n        ...identity\n    });\n};\n"],"names":["createIdentity","identity","AuthenticatedIdentity"],"mappings":";AAUO,MAAMA,iBAAiB,CAACC,WAAkC,CAAC,CAAC,GACxD,IAAIC,sBAAsB;QAC7B,IAAI;QACJ,MAAM;QACN,aAAa;QACb,GAAGD,QAAQ;IACf"}

package/index.d.ts

@@ -0,0 +1,8 @@
+export { TestIdentity, TestAuthenticator } from "./mocks/TestAuthenticator.js";
+export { TestPermissions, TestAuthorizer } from "./mocks/TestAuthorizer.js";
+export type { TestPermissionsHolder } from "./mocks/TestAuthorizer.js";
+export { InlineTaskServiceFeature } from "./mocks/InlineTaskService.js";
+export { AuthTriggerHandler } from "./handlers/AuthTriggerHandler.js";
+export { RootTenantInitializer } from "./handlers/RootTenantInitializer.js";
+export { createIdentity } from "./identity.js";
+export { defaultIdentity, FULL_ACCESS_ROLE_ID, FULL_ACCESS_TEAM_ID, UNKNOWN_TEAM_ID } from "./tenancySecurity.js";

package/index.js

@@ -0,0 +1,7 @@
+export { TestAuthenticator, TestIdentity } from "./mocks/TestAuthenticator.js";
+export { TestAuthorizer, TestPermissions } from "./mocks/TestAuthorizer.js";
+export { InlineTaskServiceFeature } from "./mocks/InlineTaskService.js";
+export { AuthTriggerHandler } from "./handlers/AuthTriggerHandler.js";
+export { RootTenantInitializer } from "./handlers/RootTenantInitializer.js";
+export { createIdentity } from "./identity.js";
+export { FULL_ACCESS_ROLE_ID, FULL_ACCESS_TEAM_ID, UNKNOWN_TEAM_ID, defaultIdentity } from "./tenancySecurity.js";

package/mocks/InlineTaskService.d.ts

@@ -0,0 +1,6 @@
+import type { Container } from "@webiny/di";
+/** Registers a {@link TaskService} that runs every triggered task inline. */
+export declare const InlineTaskServiceFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/mocks/InlineTaskService.js

@@ -0,0 +1,85 @@
+import { Result, createFeature } from "@webiny/feature/api";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { TaskDefinition, TaskResultStatus } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+const MAX_RUNS = 100;
+class InlineTaskServiceImpl {
+    constructor(container){
+        this.container = container;
+        this.nextId = 1;
+    }
+    async trigger(params) {
+        const definition = this.container.resolveAll(TaskDefinition).find((candidate)=>candidate.id === params.definition);
+        if (!definition) throw new Error(`No task definition "${params.definition}" is registered.`);
+        const handler = this.container.resolveImplementation(definition.handler);
+        const controller = this.createController();
+        let input = params.input ?? {};
+        for(let run = 1; run <= MAX_RUNS; run++){
+            const result = await handler.run({
+                input,
+                definition,
+                controller
+            });
+            if (result.status !== TaskResultStatus.CONTINUE) break;
+            if (run === MAX_RUNS) throw new Error(`Task "${definition.id}" was still continuing after ${MAX_RUNS} runs.`);
+            input = result.input;
+        }
+        const now = new Date().toISOString();
+        return Result.ok({
+            id: `inline-task-${this.nextId++}`,
+            definitionId: definition.id,
+            input,
+            createdOn: now,
+            savedOn: now
+        });
+    }
+    async abort() {
+        throw new Error("Inline tasks finish inside trigger(), so there is nothing to abort.");
+    }
+    async fetchServiceInfo() {
+        return Result.ok({});
+    }
+    createController() {
+        return {
+            runtime: {
+                isAborted: ()=>false,
+                isCloseToTimeout: ()=>false
+            },
+            response: {
+                done: (message, output)=>({
+                        status: TaskResultStatus.DONE,
+                        message,
+                        output
+                    }),
+                continue: (input)=>({
+                        status: TaskResultStatus.CONTINUE,
+                        input
+                    }),
+                error: (error)=>({
+                        status: TaskResultStatus.ERROR,
+                        error
+                    }),
+                aborted: ()=>({
+                        status: TaskResultStatus.ABORTED
+                    })
+            },
+            task: {
+                trigger: (params)=>this.trigger(params)
+            },
+            logger: {
+                info: async ()=>{},
+                error: async ()=>{},
+                warn: async ()=>{},
+                debug: async ()=>{}
+            }
+        };
+    }
+}
+const InlineTaskServiceFeature = createFeature({
+    name: "Testing/InlineTaskService",
+    register (container) {
+        container.registerInstance(TaskService, new InlineTaskServiceImpl(container));
+    }
+});
+export { InlineTaskServiceFeature };
+
+//# sourceMappingURL=InlineTaskService.js.map

package/mocks/InlineTaskService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks/InlineTaskService.js","sources":["../../src/mocks/InlineTaskService.ts"],"sourcesContent":["import type { Container } from \"@webiny/di\";\nimport { createFeature, Result } from \"@webiny/feature/api\";\nimport {\n    TaskService,\n    type ITaskTriggerParams\n} from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport {\n    TaskDefinition,\n    TaskResultStatus\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\n\n/** A task that keeps asking to continue is broken; stop it instead of hanging the test. */\nconst MAX_RUNS = 100;\n\n/*\n * A `TaskService` that runs the triggered task right away, inside `trigger`, and keeps calling it\n * while it asks to continue. Tests then see the task's effects as soon as the triggering call\n * returns, with no task records and no step function. The controller covers what the task handlers\n * use: runtime checks (never aborted, never out of time), responses, triggering further tasks and a\n * silent logger.\n */\nclass InlineTaskServiceImpl implements TaskService.Interface {\n    private nextId = 1;\n\n    constructor(private container: Container) {}\n\n    async trigger<I extends TaskDefinition.TaskInput = TaskDefinition.TaskInput>(\n        params: ITaskTriggerParams<I>\n    ) {\n        const definition = this.container\n            .resolveAll(TaskDefinition)\n            .find(candidate => candidate.id === params.definition);\n        if (!definition) {\n            throw new Error(`No task definition \"${params.definition}\" is registered.`);\n        }\n\n        const handler = this.container.resolveImplementation(definition.handler);\n        const controller = this.createController();\n\n        let input = params.input ?? ({} as I);\n        for (let run = 1; run <= MAX_RUNS; run++) {\n            const result = await handler.run({ input, definition, controller } as never);\n            if (result.status !== TaskResultStatus.CONTINUE) {\n                break;\n            }\n            if (run === MAX_RUNS) {\n                throw new Error(\n                    `Task \"${definition.id}\" was still continuing after ${MAX_RUNS} runs.`\n                );\n            }\n            input = (result as { input: I }).input;\n        }\n\n        const now = new Date().toISOString();\n        return Result.ok({\n            id: `inline-task-${this.nextId++}`,\n            definitionId: definition.id,\n            input,\n            createdOn: now,\n            savedOn: now\n        }) as never;\n    }\n\n    async abort(): Promise<never> {\n        throw new Error(\"Inline tasks finish inside trigger(), so there is nothing to abort.\");\n    }\n\n    async fetchServiceInfo() {\n        return Result.ok({});\n    }\n\n    private createController() {\n        return {\n            runtime: {\n                isAborted: () => false,\n                isCloseToTimeout: () => false\n            },\n            response: {\n                done: (message?: string, output?: unknown) => ({\n                    status: TaskResultStatus.DONE,\n                    message,\n                    output\n                }),\n                continue: (input: unknown) => ({ status: TaskResultStatus.CONTINUE, input }),\n                error: (error: unknown) => ({ status: TaskResultStatus.ERROR, error }),\n                aborted: () => ({ status: TaskResultStatus.ABORTED })\n            },\n            task: {\n                trigger: (params: ITaskTriggerParams) => this.trigger(params)\n            },\n            logger: {\n                info: async () => {},\n                error: async () => {},\n                warn: async () => {},\n                debug: async () => {}\n            }\n        };\n    }\n}\n\n/** Registers a {@link TaskService} that runs every triggered task inline. */\nexport const InlineTaskServiceFeature = createFeature({\n    name: \"Testing/InlineTaskService\",\n    register(container) {\n        container.registerInstance(TaskService, new InlineTaskServiceImpl(container));\n    }\n});\n"],"names":["MAX_RUNS","InlineTaskServiceImpl","container","params","definition","TaskDefinition","candidate","Error","handler","controller","input","run","result","TaskResultStatus","now","Date","Result","message","output","error","InlineTaskServiceFeature","createFeature","TaskService"],"mappings":";;;AAYA,MAAMA,WAAW;AASjB,MAAMC;IAGF,YAAoBC,SAAoB,CAAE;aAAtBA,SAAS,GAATA;aAFZ,MAAM,GAAG;IAE0B;IAE3C,MAAM,QACFC,MAA6B,EAC/B;QACE,MAAMC,aAAa,IAAI,CAAC,SAAS,CAC5B,UAAU,CAACC,gBACX,IAAI,CAACC,CAAAA,YAAaA,UAAU,EAAE,KAAKH,OAAO,UAAU;QACzD,IAAI,CAACC,YACD,MAAM,IAAIG,MAAM,CAAC,oBAAoB,EAAEJ,OAAO,UAAU,CAAC,gBAAgB,CAAC;QAG9E,MAAMK,UAAU,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAACJ,WAAW,OAAO;QACvE,MAAMK,aAAa,IAAI,CAAC,gBAAgB;QAExC,IAAIC,QAAQP,OAAO,KAAK,IAAK,CAAC;QAC9B,IAAK,IAAIQ,MAAM,GAAGA,OAAOX,UAAUW,MAAO;YACtC,MAAMC,SAAS,MAAMJ,QAAQ,GAAG,CAAC;gBAAEE;gBAAON;gBAAYK;YAAW;YACjE,IAAIG,OAAO,MAAM,KAAKC,iBAAiB,QAAQ,EAC3C;YAEJ,IAAIF,QAAQX,UACR,MAAM,IAAIO,MACN,CAAC,MAAM,EAAEH,WAAW,EAAE,CAAC,6BAA6B,EAAEJ,SAAS,MAAM,CAAC;YAG9EU,QAASE,OAAwB,KAAK;QAC1C;QAEA,MAAME,MAAM,IAAIC,OAAO,WAAW;QAClC,OAAOC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,IAAI;YAClC,cAAcZ,WAAW,EAAE;YAC3BM;YACA,WAAWI;YACX,SAASA;QACb;IACJ;IAEA,MAAM,QAAwB;QAC1B,MAAM,IAAIP,MAAM;IACpB;IAEA,MAAM,mBAAmB;QACrB,OAAOS,OAAO,EAAE,CAAC,CAAC;IACtB;IAEQ,mBAAmB;QACvB,OAAO;YACH,SAAS;gBACL,WAAW,IAAM;gBACjB,kBAAkB,IAAM;YAC5B;YACA,UAAU;gBACN,MAAM,CAACC,SAAkBC,SAAsB;wBAC3C,QAAQL,iBAAiB,IAAI;wBAC7BI;wBACAC;oBACJ;gBACA,UAAU,CAACR,QAAoB;wBAAE,QAAQG,iBAAiB,QAAQ;wBAAEH;oBAAM;gBAC1E,OAAO,CAACS,QAAoB;wBAAE,QAAQN,iBAAiB,KAAK;wBAAEM;oBAAM;gBACpE,SAAS,IAAO;wBAAE,QAAQN,iBAAiB,OAAO;oBAAC;YACvD;YACA,MAAM;gBACF,SAAS,CAACV,SAA+B,IAAI,CAAC,OAAO,CAACA;YAC1D;YACA,QAAQ;gBACJ,MAAM,WAAa;gBACnB,OAAO,WAAa;gBACpB,MAAM,WAAa;gBACnB,OAAO,WAAa;YACxB;QACJ;IACJ;AACJ;AAGO,MAAMiB,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASnB,SAAS;QACdA,UAAU,gBAAgB,CAACoB,aAAa,IAAIrB,sBAAsBC;IACtE;AACJ"}

package/mocks/TestAuthenticator.d.ts

@@ -0,0 +1,17 @@
+import { Abstraction } from "@webiny/di";
+import type { IAuthenticator } from "@webiny/api-core/features/security/authentication/Authenticator/abstractions.js";
+import type { IdentityData } from "@webiny/api-core/features/security/IdentityContext/index.js";
+/**
+ * The identity a test authenticates as. Register an instance in the (root) container to control
+ * who the request runs as: `container.registerInstance(TestIdentity, createIdentity({...}))`.
+ */
+export declare const TestIdentity: Abstraction<IdentityData | null>;
+declare class TestAuthenticatorImpl implements IAuthenticator {
+    private identity;
+    constructor(identity: IdentityData | null);
+    authenticate(_token: string): Promise<any>;
+}
+export declare const TestAuthenticator: typeof TestAuthenticatorImpl & {
+    __abstraction: Abstraction<IAuthenticator>;
+};
+export {};

package/mocks/TestAuthenticator.js

@@ -0,0 +1,20 @@
+import { Abstraction } from "@webiny/di";
+import { Authenticator } from "@webiny/api-core/features/security/authentication/Authenticator/abstractions.js";
+const TestIdentity = new Abstraction("TestIdentity");
+class TestAuthenticatorImpl {
+    constructor(identity){
+        this.identity = identity;
+    }
+    async authenticate(_token) {
+        return this.identity;
+    }
+}
+const TestAuthenticator = Authenticator.createImplementation({
+    implementation: TestAuthenticatorImpl,
+    dependencies: [
+        TestIdentity
+    ]
+});
+export { TestAuthenticator, TestIdentity };
+
+//# sourceMappingURL=TestAuthenticator.js.map

package/mocks/TestAuthenticator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks/TestAuthenticator.js","sources":["../../src/mocks/TestAuthenticator.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport { Authenticator } from \"@webiny/api-core/features/security/authentication/Authenticator/abstractions.js\";\nimport type { IAuthenticator } from \"@webiny/api-core/features/security/authentication/Authenticator/abstractions.js\";\nimport type { IdentityData } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\n\n/**\n * The identity a test authenticates as. Register an instance in the (root) container to control\n * who the request runs as: `container.registerInstance(TestIdentity, createIdentity({...}))`.\n */\nexport const TestIdentity = new Abstraction<IdentityData | null>(\"TestIdentity\");\n\nclass TestAuthenticatorImpl implements IAuthenticator {\n    constructor(private identity: IdentityData | null) {}\n\n    async authenticate(_token: string): Promise<any> {\n        return this.identity;\n    }\n}\n\nexport const TestAuthenticator = Authenticator.createImplementation({\n    implementation: TestAuthenticatorImpl,\n    dependencies: [TestIdentity]\n});\n"],"names":["TestIdentity","Abstraction","TestAuthenticatorImpl","identity","_token","TestAuthenticator","Authenticator"],"mappings":";;AASO,MAAMA,eAAe,IAAIC,YAAiC;AAEjE,MAAMC;IACF,YAAoBC,QAA6B,CAAE;aAA/BA,QAAQ,GAARA;IAAgC;IAEpD,MAAM,aAAaC,MAAc,EAAgB;QAC7C,OAAO,IAAI,CAAC,QAAQ;IACxB;AACJ;AAEO,MAAMC,oBAAoBC,cAAc,oBAAoB,CAAC;IAChE,gBAAgBJ;IAChB,cAAc;QAACF;KAAa;AAChC"}

package/mocks/TestAuthorizer.d.ts

@@ -0,0 +1,29 @@
+import { Abstraction } from "@webiny/di";
+import type { IAuthorizer } from "@webiny/api-core/features/security/authorization/Authorizer/abstractions.js";
+import type { SecurityPermission } from "@webiny/api-core/types/security.js";
+import type { Identity, IdentityData } from "@webiny/api-core/features/security/IdentityContext/index.js";
+/**
+ * The permissions granted to the test identity, wrapped in a holder so DI treats it as a single
+ * value (not a multiple-binding of SecurityPermission):
+ * `container.registerInstance(TestPermissions, { list: [{ name: "*" }] })`.
+ *
+ * `byIdentity` grants other identities their own permissions (by identity id), for code that
+ * evaluates another user through `IdentityContext.withIdentity`. Other identities not listed get
+ * no permissions.
+ */
+export interface TestPermissionsHolder {
+    list: SecurityPermission[];
+    byIdentity?: Record<string, SecurityPermission[]>;
+}
+export declare const TestPermissions: Abstraction<TestPermissionsHolder>;
+declare class TestAuthorizerImpl implements IAuthorizer {
+    private permissions;
+    private requestIdentity;
+    constructor(permissions: TestPermissionsHolder, requestIdentity: IdentityData | null);
+    authorize(identity: Identity): Promise<SecurityPermission[] | null>;
+    private isRequestIdentity;
+}
+export declare const TestAuthorizer: typeof TestAuthorizerImpl & {
+    __abstraction: Abstraction<IAuthorizer>;
+};
+export {};

package/mocks/TestAuthorizer.js

@@ -0,0 +1,33 @@
+import { Abstraction } from "@webiny/di";
+import { Authorizer } from "@webiny/api-core/features/security/authorization/Authorizer/abstractions.js";
+import { TestIdentity } from "./TestAuthenticator.js";
+const TestPermissions = new Abstraction("TestPermissions");
+class TestAuthorizerImpl {
+    constructor(permissions, requestIdentity){
+        this.permissions = permissions;
+        this.requestIdentity = requestIdentity;
+    }
+    async authorize(identity) {
+        if (this.isRequestIdentity(identity)) {
+            if (this.permissions.list.length > 0) return this.permissions.list;
+            if ("api-key" === identity.type) return identity.permissions;
+            return this.permissions.list;
+        }
+        if ("api-key" === identity.type) return null;
+        return this.permissions.byIdentity?.[identity.id] ?? [];
+    }
+    isRequestIdentity(identity) {
+        if (!this.requestIdentity) return identity.isAnonymous();
+        return identity.id === this.requestIdentity.id;
+    }
+}
+const TestAuthorizer = Authorizer.createImplementation({
+    implementation: TestAuthorizerImpl,
+    dependencies: [
+        TestPermissions,
+        TestIdentity
+    ]
+});
+export { TestAuthorizer, TestPermissions };
+
+//# sourceMappingURL=TestAuthorizer.js.map

package/mocks/TestAuthorizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mocks/TestAuthorizer.js","sources":["../../src/mocks/TestAuthorizer.ts"],"sourcesContent":["import { Abstraction } from \"@webiny/di\";\nimport { Authorizer } from \"@webiny/api-core/features/security/authorization/Authorizer/abstractions.js\";\nimport type { IAuthorizer } from \"@webiny/api-core/features/security/authorization/Authorizer/abstractions.js\";\nimport type { SecurityPermission } from \"@webiny/api-core/types/security.js\";\nimport type {\n    Identity,\n    IdentityData\n} from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { TestIdentity } from \"./TestAuthenticator.js\";\n\n/**\n * The permissions granted to the test identity, wrapped in a holder so DI treats it as a single\n * value (not a multiple-binding of SecurityPermission):\n * `container.registerInstance(TestPermissions, { list: [{ name: \"*\" }] })`.\n *\n * `byIdentity` grants other identities their own permissions (by identity id), for code that\n * evaluates another user through `IdentityContext.withIdentity`. Other identities not listed get\n * no permissions.\n */\nexport interface TestPermissionsHolder {\n    list: SecurityPermission[];\n    byIdentity?: Record<string, SecurityPermission[]>;\n}\n\nexport const TestPermissions = new Abstraction<TestPermissionsHolder>(\"TestPermissions\");\n\nclass TestAuthorizerImpl implements IAuthorizer {\n    constructor(\n        private permissions: TestPermissionsHolder,\n        private requestIdentity: IdentityData | null\n    ) {}\n\n    async authorize(identity: Identity): Promise<SecurityPermission[] | null> {\n        if (this.isRequestIdentity(identity)) {\n            if (this.permissions.list.length > 0) {\n                return this.permissions.list;\n            }\n            // An API-key request identity with embedded permissions (mirrors ApiKeyAuthorizer).\n            if (identity.type === \"api-key\") {\n                return identity.permissions;\n            }\n            return this.permissions.list;\n        }\n        // A real API key authenticated during the test: leave it to api-core's ApiKeyAuthorizer.\n        if (identity.type === \"api-key\") {\n            return null;\n        }\n        // Another identity (withIdentity): only what the test granted it (R70).\n        return this.permissions.byIdentity?.[identity.id] ?? [];\n    }\n\n    private isRequestIdentity(identity: Identity): boolean {\n        if (!this.requestIdentity) {\n            return identity.isAnonymous();\n        }\n        return identity.id === this.requestIdentity.id;\n    }\n}\n\nexport const TestAuthorizer = Authorizer.createImplementation({\n    implementation: TestAuthorizerImpl,\n    dependencies: [TestPermissions, TestIdentity]\n});\n"],"names":["TestPermissions","Abstraction","TestAuthorizerImpl","permissions","requestIdentity","identity","TestAuthorizer","Authorizer","TestIdentity"],"mappings":";;;AAwBO,MAAMA,kBAAkB,IAAIC,YAAmC;AAEtE,MAAMC;IACF,YACYC,WAAkC,EAClCC,eAAoC,CAC9C;aAFUD,WAAW,GAAXA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,UAAUC,QAAkB,EAAwC;QACtE,IAAI,IAAI,CAAC,iBAAiB,CAACA,WAAW;YAClC,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,GAAG,GAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI;YAGhC,IAAIA,AAAkB,cAAlBA,SAAS,IAAI,EACb,OAAOA,SAAS,WAAW;YAE/B,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI;QAChC;QAEA,IAAIA,AAAkB,cAAlBA,SAAS,IAAI,EACb,OAAO;QAGX,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAACA,SAAS,EAAE,CAAC,IAAI,EAAE;IAC3D;IAEQ,kBAAkBA,QAAkB,EAAW;QACnD,IAAI,CAAC,IAAI,CAAC,eAAe,EACrB,OAAOA,SAAS,WAAW;QAE/B,OAAOA,SAAS,EAAE,KAAK,IAAI,CAAC,eAAe,CAAC,EAAE;IAClD;AACJ;AAEO,MAAMC,iBAAiBC,WAAW,oBAAoB,CAAC;IAC1D,gBAAgBL;IAChB,cAAc;QAACF;QAAiBQ;KAAa;AACjD"}

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@webiny/api-core-testing",
+	"version": "0.0.0-unstable.0156a4c312",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-testing"
+	},
+	"description": "Shared test utilities for Webiny API packages (mocks, auth/tenant test decorators, identity helpers).",
+	"author": "Webiny Ltd.",
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api-core": "0.0.0-unstable.0156a4c312",
+		"@webiny/di": "2.0.0",
+		"@webiny/event-handler-core": "0.0.0-unstable.0156a4c312",
+		"@webiny/feature": "0.0.0-unstable.0156a4c312"
+	},
+	"devDependencies": {
+		"@webiny/build-tools": "0.0.0-unstable.0156a4c312",
+		"rimraf": "6.1.3",
+		"typescript": "7.0.2"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/tenancySecurity.d.ts

@@ -0,0 +1,10 @@
+import { IdentityData } from "@webiny/api-core/features/security/IdentityContext/index.js";
+/**
+ * Shared test tenancy/security constants (the default admin identity + full-access role/team ids).
+ * Runtime tenancy/security setup is DI-native (TestAuthenticator/TestAuthorizer + the CMS test
+ * handler); these plain constants live here in the base test-utils package.
+ */
+export declare const defaultIdentity: IdentityData;
+export declare const FULL_ACCESS_ROLE_ID = "full-access-role";
+export declare const FULL_ACCESS_TEAM_ID = "full-access-team";
+export declare const UNKNOWN_TEAM_ID = "unknown-team";

package/tenancySecurity.js

@@ -0,0 +1,11 @@
+const defaultIdentity = {
+    id: "id-12345678",
+    type: "admin",
+    displayName: "John Doe"
+};
+const FULL_ACCESS_ROLE_ID = "full-access-role";
+const FULL_ACCESS_TEAM_ID = "full-access-team";
+const UNKNOWN_TEAM_ID = "unknown-team";
+export { FULL_ACCESS_ROLE_ID, FULL_ACCESS_TEAM_ID, UNKNOWN_TEAM_ID, defaultIdentity };
+
+//# sourceMappingURL=tenancySecurity.js.map

package/tenancySecurity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenancySecurity.js","sources":["../src/tenancySecurity.ts"],"sourcesContent":["import { IdentityData } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\n\n/**\n * Shared test tenancy/security constants (the default admin identity + full-access role/team ids).\n * Runtime tenancy/security setup is DI-native (TestAuthenticator/TestAuthorizer + the CMS test\n * handler); these plain constants live here in the base test-utils package.\n */\nexport const defaultIdentity: IdentityData = {\n    id: \"id-12345678\",\n    type: \"admin\",\n    displayName: \"John Doe\"\n};\n\nexport const FULL_ACCESS_ROLE_ID = \"full-access-role\";\nexport const FULL_ACCESS_TEAM_ID = \"full-access-team\";\nexport const UNKNOWN_TEAM_ID = \"unknown-team\";\n"],"names":["defaultIdentity","FULL_ACCESS_ROLE_ID","FULL_ACCESS_TEAM_ID","UNKNOWN_TEAM_ID"],"mappings":"AAOO,MAAMA,kBAAgC;IACzC,IAAI;IACJ,MAAM;IACN,aAAa;AACjB;AAEO,MAAMC,sBAAsB;AAC5B,MAAMC,sBAAsB;AAC5B,MAAMC,kBAAkB"}