@appsemble/e2e 0.32.2

package/LICENSE.md

@@ -0,0 +1,126 @@
+# GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright © 2018 Appsemble B.V. <https://appsemble.com>
+
+Everyone is permitted to copy and distribute verbatim copies of this license document, but changing
+it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the terms and conditions of
+version 3 of the GNU General Public License, supplemented by the additional permissions listed
+below.
+
+## 0. Additional Definitions.
+
+As used herein, _“this License”_ refers to version 3 of the GNU Lesser General Public License, and
+the _“GNU GPL”_ refers to version 3 of the GNU General Public License.
+
+_“The Library”_ refers to a covered work governed by this License, other than an Application or a
+Combined Work as defined below.
+
+An _“Application”_ is any work that makes use of an interface provided by the Library, but which is
+not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed
+a mode of using an interface provided by the Library.
+
+A _“Combined Work”_ is a work produced by combining or linking an Application with the Library. The
+particular version of the Library with which the Combined Work was made is also called the _“Linked
+Version”_.
+
+The _“Minimal Corresponding Source”_ for a Combined Work means the Corresponding Source for the
+Combined Work, excluding any source code for portions of the Combined Work that, considered in
+isolation, are based on the Application, and not on the Linked Version.
+
+The _“Corresponding Application Code”_ for a Combined Work means the object code and/or source code
+for the Application, including any data and utility programs needed for reproducing the Combined
+Work from the Application, but excluding the System Libraries of the Combined Work.
+
+## 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License without being bound by section
+3 of the GNU GPL.
+
+## 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a facility refers to a function or
+data to be supplied by an Application that uses the facility (other than as an argument passed when
+the facility is invoked), then you may convey a copy of the modified version:
+
+- a) under this License, provided that you make a good faith effort to ensure that, in the event an
+  Application does not supply the function or data, the facility still operates, and performs
+  whatever part of its purpose remains meaningful, or
+- b) under the GNU GPL, with none of the additional permissions of this License applicable to that
+  copy.
+
+## 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a header file that is part of
+the Library. You may convey such object code under terms of your choice, provided that, if the
+incorporated material is not limited to numerical parameters, data structure layouts and accessors,
+or small macros, inline functions and templates (ten or fewer lines in length), you do both of the
+following:
+
+- a) Give prominent notice with each copy of the object code that the Library is used in it and that
+  the Library and its use are covered by this License.
+- b) Accompany the object code with a copy of the GNU GPL and this license document.
+
+## 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken together, effectively do not
+restrict modification of the portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of the following:
+
+- a) Give prominent notice with each copy of the Combined Work that the Library is used in it and
+  that the Library and its use are covered by this License.
+- b) Accompany the Combined Work with a copy of the GNU GPL and this license document.
+- c) For a Combined Work that displays copyright notices during execution, include the copyright
+  notice for the Library among these notices, as well as a reference directing the user to the
+  copies of the GNU GPL and this license document.
+- d) Do one of the following:
+  1. Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding
+     Application Code in a form suitable for, and under terms that permit, the user to recombine or
+     relink the Application with a modified version of the Linked Version to produce a modified
+     Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding
+     Source.
+  2. Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is
+     one that (a) uses at run time a copy of the Library already present on the user’s computer
+     system, and (b) will operate properly with a modified version of the Library that is
+     interface-compatible with the Linked Version.
+- e) Provide Installation Information, but only if you would otherwise be required to provide such
+  information under section 6 of the GNU GPL, and only to the extent that such information is
+  necessary to install and execute a modified version of the Combined Work produced by recombining
+  or relinking the Application with a modified version of the Linked Version. (If you use option
+  4d0, the Installation Information must accompany the Minimal Corresponding Source and
+  Corresponding Application Code. If you use option 4d1, you must provide the Installation
+  Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding
+  Source.)
+
+## 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library side by side in a single
+library together with other library facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your choice, if you do both of the
+following:
+
+- a) Accompany the combined library with a copy of the same work based on the Library, uncombined
+  with any other library facilities, conveyed under the terms of this License.
+- b) Give prominent notice with the combined library that part of it is a work based on the Library,
+  and explaining where to find the accompanying uncombined form of the same work.
+
+## 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General
+Public License from time to time. Such new versions will be similar in spirit to the present
+version, but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library as you received it specifies
+that a certain numbered version of the GNU Lesser General Public License _“or any later version”_
+applies to it, you have the option of following the terms and conditions either of that published
+version or of any later version published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser General Public License, you may
+choose any version of the GNU Lesser General Public License ever published by the Free Software
+Foundation.
+
+If the Library as you received it specifies that a proxy can decide whether future versions of the
+GNU Lesser General Public License shall apply, that proxy’s public statement of acceptance of any
+version is permanent authorization for you to choose that version for the Library.

package/README.md

@@ -0,0 +1,64 @@
+# ![](https://gitlab.com/appsemble/appsemble/-/raw/0.32.2/config/assets/logo.svg) Appsemble End 2 End Tests
+
+> Run end 2 end tests on an Appsemble environment
+
+[![GitLab CI](https://gitlab.com/appsemble/appsemble/badges/0.32.2/pipeline.svg)](https://gitlab.com/appsemble/appsemble/-/releases/0.32.2)
+[![Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io)
+
+## Table of Contents
+
+- [Usage](#usage)
+- [License](#license)
+
+## Usage
+
+To run end to end tests, run:
+
+```sh
+npm run e2e
+```
+
+The tests use [Playwright](https://playwright.dev/).
+
+After each test a video will be saved in the `packages/e2e/test-results/{name-test}` directory for
+further inspection.
+
+The end to end tests use the following environment variables:
+
+- `BOT_ACCOUNT_EMAIL` — The email address used to login.
+- `BOT_ACCOUNT_PASSWORD` — The password used to login.
+- `CI_MERGE_REQUEST_IID` — By default tests are run against the staging environment on
+  <https://staging.appsemble.review>. If this variable is specified, tests are run against the merge
+  request review environment instead.
+- `ACCESS_TOKEN` — The access token of the account that's logged in.
+
+### Fixtures
+
+Common end-to-end fixtures are defined under the `fixtures` directory. These are exported for other
+packages to use, like client apps. This can be done by installing this package and importing `test`
+or `expect`.
+
+### Authentication
+
+Some fixtures call the Appsemble API using the Playwright `request` object. This expects you to have
+set an access token as environment variable with the name **ACCESS_TOKEN** beforehand. The easiest
+way to do this is by setting it in a setup step using the `loginUser` fixture.
+
+`auth.setup.ts`
+
+```ts
+setup('authenticate', async ({ loginUser }) => {
+  const accessToken = await loginUser('bot', '12345');
+  process.env.ACCESS_TOKEN = accessToken;
+});
+```
+
+## Contributing
+
+When writing end-to-end tests, have a look at the
+[best practices](../../CONTRIBUTING.md#best-practices) to help you write solid tests.
+
+## License
+
+[LGPL-3.0-only](https://gitlab.com/appsemble/appsemble/-/blob/0.32.2/LICENSE.md) ©
+[Appsemble](https://appsemble.com)

package/fixtures/expect/index.d.ts

@@ -0,0 +1,5 @@
+import { type Expect } from '@playwright/test';
+import { type TrainingMatchers } from './training/index.js';
+type ExpectFixtures = TrainingMatchers;
+export declare const expect: Expect<ExpectFixtures>;
+export {};

package/fixtures/expect/index.js

@@ -0,0 +1,4 @@
+import { mergeExpects } from '@playwright/test';
+import { expect as trainingMatchers } from './training/index.js';
+export const expect = mergeExpects(trainingMatchers);
+//# sourceMappingURL=index.js.map

package/fixtures/expect/training/index.d.ts

@@ -0,0 +1,17 @@
+import { type TrainingStatus } from '@appsemble/types';
+import { type Locator } from '@playwright/test';
+export interface TrainingMatchers {
+    /**
+     * Asserts whether all child elements of this training node are correct for the given state
+     *
+     * @param status Status of the training
+     */
+    toHaveChapterStatus: (trainingNode: Locator, status: TrainingStatus) => Promise<void>;
+}
+export declare const expect: import("@playwright/test").Expect<{
+    toHaveChapterStatus(this: import("@playwright/test").ExpectMatcherState, trainingNode: Locator, status: TrainingStatus): Promise<{
+        message: () => string;
+        pass: true;
+        name: string;
+    }>;
+}>;

package/fixtures/expect/training/index.js

@@ -0,0 +1,30 @@
+import { expect as base } from '@playwright/test';
+import { availableColor, blockedColor, completedColor, inProgressColor, } from '../../../tests/studio/trainings/constants.js';
+export const expect = base.extend({
+    async toHaveChapterStatus(trainingNode, status) {
+        let backgroundColor = availableColor;
+        let title = 'node-title-available';
+        switch (status) {
+            case 'blocked':
+                backgroundColor = blockedColor;
+                title = 'node-title-blocked';
+                break;
+            case 'completed':
+                backgroundColor = completedColor;
+                break;
+            case 'in progress':
+                backgroundColor = inProgressColor;
+                break;
+            default:
+                backgroundColor = availableColor;
+        }
+        await expect(trainingNode.getByTestId('status-circle')).toHaveCSS('background-color', backgroundColor);
+        await expect(trainingNode.getByTestId(title)).toBeVisible();
+        return {
+            message: () => 'All elements are valid',
+            pass: true,
+            name: 'toHaveChapterStatus',
+        };
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/index.d.ts

@@ -0,0 +1,2 @@
+export { expect } from './expect/index.js';
+export { test } from './test/index.js';

package/fixtures/index.js

@@ -0,0 +1,3 @@
+export { expect } from './expect/index.js';
+export { test } from './test/index.js';
+//# sourceMappingURL=index.js.map

package/fixtures/test/app/index.d.ts

@@ -0,0 +1,24 @@
+import { type App } from '@appsemble/types';
+export interface AppFixtures {
+    /**
+     * Create an app.
+     */
+    createApp: (organization: string, yaml: string) => Promise<App>;
+    /**
+     * Set the role of the user.
+     *
+     * Note that this requires the user to be logged in to the studio.
+     *
+     * @param appId The ID of the app to set the role for.
+     * @param role The role to set.
+     */
+    changeAppMemberRole: (appId: number, role: string) => Promise<void>;
+    /**
+     * Gets the ID of an app
+     *
+     * @param appPath Path of the app
+     * @returns ID of the app
+     */
+    getAppId: (appPath: string) => Promise<number>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & AppFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/app/index.js

@@ -0,0 +1,40 @@
+import { test as base } from '@playwright/test';
+import stripIndent from 'strip-indent';
+import { expect } from '../../expect/index.js';
+export const test = base.extend({
+    async createApp({ request }, use) {
+        await use(async (organization, yaml) => {
+            const formData = new FormData();
+            formData.append('OrganizationId', organization.toLowerCase());
+            formData.append('yaml', stripIndent(yaml));
+            const response = await request.post('/api/apps', {
+                data: formData,
+                headers: {
+                    Authorization: `Bearer ${process.env.ACCESS_TOKEN}`,
+                },
+            });
+            expect(response.status()).toBe(201);
+            const app = (await response.json());
+            expect(app).not.toBeNull();
+            return app;
+        });
+    },
+    async changeAppMemberRole({ browser }, use) {
+        await use(async (appId, role) => {
+            const page = await browser.newPage();
+            await page.goto(`/en/apps/${appId}/-/users`);
+            const select = page.locator('tr', { hasText: 'It’s you!' }).locator('select[class=""]');
+            await select.selectOption(role);
+            await page.close();
+        });
+    },
+    async getAppId({ request }, use) {
+        await use(async (appPath) => {
+            const apps = await (await request.get('/api/apps')).json();
+            const appId = apps.find(({ path }) => path === appPath)?.id;
+            expect(appId).not.toBeUndefined();
+            return appId;
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/app-collection/index.d.ts

@@ -0,0 +1,22 @@
+export interface AppCollectionFixtures {
+    /**
+     * Creates an app collection for the given organization
+     *
+     * @param organizationId ID of the organization to create the collection for
+     * @param collectionName Name of the collection
+     * @param expertName Name of the expert
+     * @param expertDescription Description of the expert
+     * @param headerImage Image that will be placed as the header of the collection
+     * @param expertPhoto Photo that represents the expert
+     * @param isPrivate Whether the collection should be private or not
+     */
+    createAppCollection: (organizationId: string, collectionName: string, expertName: string, expertDescription: string, headerImage: string, expertPhoto: string, isPrivate: boolean) => Promise<void>;
+    /**
+     * Delete an existing app collection
+     *
+     * @param organizationId ID of the organization which the collection belongs to
+     * @param collectionName Name of the collection
+     */
+    deleteAppCollection: (organizationId: string, collectionName: string) => Promise<void>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & AppCollectionFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/app-collection/index.js

@@ -0,0 +1,42 @@
+import { test as base } from '@playwright/test';
+import { expect } from '../../../index.js';
+export const test = base.extend({
+    async createAppCollection({ page }, use) {
+        await use(async (organizationId, collectionName, expertName, expertDescription, headerImage, expertPhoto, isPrivate) => {
+            await page.goto(`/en/organizations/${organizationId}/collections`);
+            await page.getByRole('link', { name: 'App collections' }).first().click();
+            await page.getByRole('button', { name: 'Create new app collection' }).click();
+            await page.getByLabel('Name', { exact: true }).fill(collectionName);
+            await page
+                .locator('span')
+                .filter({ hasText: 'Header image' })
+                .first()
+                .setInputFiles(headerImage);
+            if (isPrivate) {
+                await page.getByText('Hide this app collection from the public list').click();
+            }
+            await page.getByLabel('Expert name').fill(expertName);
+            await page.getByLabel('Expert description').fill(expertDescription);
+            await page
+                .locator('span')
+                .filter({ hasText: 'Expert photo' })
+                .first()
+                .setInputFiles(expertPhoto);
+            // Avatar editor
+            await page.getByRole('button', { name: 'Save' }).click();
+            await page.getByRole('button', { name: 'Create app collection' }).click();
+            await expect(page.getByRole('heading', { name: collectionName })).toBeVisible();
+        });
+    },
+    async deleteAppCollection({ page }, use) {
+        await use(async (organizationId, collectionName) => {
+            await page.goto(`/en/organizations/${organizationId}/collections`);
+            await page.getByRole('link', { name: collectionName }).click();
+            await page.getByRole('link', { name: 'Settings' }).click();
+            await page.getByRole('button', { name: 'Delete app collection' }).click();
+            await page.getByRole('button', { name: 'Delete app collection', exact: true }).click();
+            await expect(page.getByRole('heading', { name: collectionName })).toBeHidden();
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/demo-app/index.d.ts

@@ -0,0 +1,15 @@
+export interface DemoAppFixtures {
+    /**
+     * Reseed the given app
+     *
+     * @param appId The ID of the app to reseed
+     */
+    reseedDemoApp: (appId: number) => Promise<void>;
+    /**
+     * Login to an Appsemble demo app.
+     *
+     * @param role The role to login in as.
+     */
+    loginDemoApp: (role: string) => Promise<void>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & DemoAppFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/demo-app/index.js

@@ -0,0 +1,22 @@
+import { test as base } from '@playwright/test';
+export const test = base.extend({
+    async reseedDemoApp({ browser }, use) {
+        await use(async (appId) => {
+            const page = await browser.newPage();
+            await page.goto(`/en/apps/${appId}/-/`);
+            await page.getByRole('button', { name: 'Reseed App' }).click();
+            await page.getByRole('button', { name: 'Reseed', exact: true }).click();
+            await page.close();
+        });
+    },
+    async loginDemoApp({ page }, use) {
+        await use(async (role) => {
+            const btn = page.getByTestId('create-account');
+            if (await btn.isVisible()) {
+                await page.getByTestId('app-role').selectOption(role);
+                await btn.click();
+            }
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/group/index.d.ts

@@ -0,0 +1,11 @@
+export interface GroupFixtures {
+    /**
+     * Set the role of the member in a group.
+     *
+     * @param appId The app to set the role for.
+     * @param group The group to set the role for.
+     * @param role The role to set.
+     */
+    changeGroupRole: (appId: number, group: string, role: string) => Promise<void>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & GroupFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/group/index.js

@@ -0,0 +1,13 @@
+import { test as base } from '@playwright/test';
+export const test = base.extend({
+    async changeGroupRole({ browser }, use) {
+        await use(async (appId, group, role) => {
+            const page = await browser.newPage();
+            await page.goto(`/en/apps/${appId}/-/groups`);
+            await page.click(`text=${group}`);
+            await page.getByRole('row', { name: 'Bot' }).locator('#role').selectOption(role);
+            await page.close();
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/index.d.ts

@@ -0,0 +1 @@
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./app/index.js").AppFixtures & import("./app-collection/index.js").AppCollectionFixtures & import("./demo-app/index.js").DemoAppFixtures & import("./group/index.js").GroupFixtures & import("./live-app/index.js").LiveAppFixtures & import("./resource/index.js").ResourceFixtures & import("./studio/index.js").StudioFixtures & import("./training/index.js").TrainingFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/index.js

@@ -0,0 +1,11 @@
+import { mergeTests } from '@playwright/test';
+import { test as appFixtures } from './app/index.js';
+import { test as appCollectionFixtures } from './app-collection/index.js';
+import { test as demoAppFixtures } from './demo-app/index.js';
+import { test as groupFixtures } from './group/index.js';
+import { test as liveAppFixtures } from './live-app/index.js';
+import { test as resourceFixtures } from './resource/index.js';
+import { test as studioFixtures } from './studio/index.js';
+import { test as trainingFixtures } from './training/index.js';
+export const test = mergeTests(appFixtures, appCollectionFixtures, demoAppFixtures, groupFixtures, liveAppFixtures, resourceFixtures, studioFixtures, trainingFixtures);
+//# sourceMappingURL=index.js.map

package/fixtures/test/live-app/index.d.ts

@@ -0,0 +1,27 @@
+export interface LiveAppFixtures {
+    /**
+     * Visit an app.
+     *
+     * @param appId The app id.
+     */
+    visitApp: (appPath: string) => Promise<void>;
+    /**
+     * Login to an app with the Appsemble OAuth2 flow.
+     */
+    loginAppAppsembleOAuth: () => Promise<void>;
+    /**
+     * Gives the app consent to perform actions on the app member's behalf
+     *
+     * This makes it so the consent screen doesn't pop up when trying to log in
+     *
+     * @param appId ID of the app to give consent to
+     */
+    giveAppConsent: (appId: number) => Promise<void>;
+    /**
+     * Gets the URL to visit the live app
+     *
+     * @param appId ID of the app
+     */
+    getLiveAppURL: (appId: number) => Promise<string>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & LiveAppFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/live-app/index.js

@@ -0,0 +1,50 @@
+import { test as base } from '@playwright/test';
+import { expect } from '../../expect/index.js';
+export const test = base.extend({
+    async visitApp({ getLiveAppURL, page, request }, use) {
+        await use(async (appPath) => {
+            const apps = await (await request.get('/api/apps')).json();
+            const appId = apps.find(({ path }) => path === appPath)?.id;
+            expect(appId).not.toBeUndefined();
+            const url = await getLiveAppURL(appId);
+            await page.goto(url);
+        });
+    },
+    async loginAppAppsembleOAuth({ page }, use) {
+        await use(async () => {
+            await page.waitForURL('**/Login**');
+            const params = new URLSearchParams(page.url().split('Login?')[1]);
+            const redirect = params.get('redirect');
+            await page.getByTestId('login-with-appsemble').click();
+            await page.waitForURL(`**${redirect}`);
+        });
+    },
+    async giveAppConsent({ getLiveAppURL, request }, use) {
+        await use(async (appId) => {
+            const url = await getLiveAppURL(appId);
+            const response = await request.post(`/api/users/current/auth/oauth2/apps/${appId}/consent/agree`, {
+                data: {
+                    redirectUri: url,
+                    scope: 'openid',
+                },
+                headers: {
+                    Authorization: `Bearer ${process.env.ACCESS_TOKEN}`,
+                },
+            });
+            expect(response.status()).toBe(201);
+        });
+    },
+    async getLiveAppURL({ baseURL, request }, use) {
+        await use(async (appId) => {
+            expect(baseURL).not.toBeUndefined();
+            const response = await request.get(`/api/apps/${appId}`);
+            expect(response.status()).toBe(200);
+            const { OrganizationId, domain, path } = (await response.json());
+            expect(path).not.toBeNull();
+            const baseUrl = new URL(baseURL);
+            const origin = domain || `${path}.${OrganizationId}.${baseUrl.host}`;
+            return `${baseUrl.protocol}//${origin}`;
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/resource/index.d.ts

@@ -0,0 +1,18 @@
+import { type Resource } from '@appsemble/types';
+export interface ResourceFixtures {
+    /**
+     * Create resource(s) from JSON input.
+     *
+     * @param appId The ID of the app.
+     * @param type The resource type.
+     * @param input The resource JSON input.
+     */
+    createResource: (appId: number, type: string, input: unknown) => Promise<Resource>;
+    /**
+     * Delete all resources from an app.
+     *
+     * @param appId Id of the app to delete the resources of.
+     */
+    deleteAllResources: (appId: number) => Promise<void>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & ResourceFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/fixtures/test/resource/index.js

@@ -0,0 +1,29 @@
+import { test as base } from '@playwright/test';
+import { expect } from '../../expect/index.js';
+export const test = base.extend({
+    async createResource({ request }, use) {
+        await use(async (appId, type, input) => {
+            const response = await request.post(`/api/apps/${appId}/resources/${type}`, {
+                data: JSON.stringify(input),
+                headers: {
+                    Authorization: `Bearer ${process.env.ACCESS_TOKEN}`,
+                },
+            });
+            expect(response.status()).toBe(201);
+            const resource = (await response.json());
+            expect(resource).not.toBeNull();
+            return resource;
+        });
+    },
+    async deleteAllResources({ request }, use) {
+        await use(async (appId) => {
+            const response = await request.delete(`/api/apps/${appId}/resources`, {
+                headers: {
+                    Authorization: `Bearer ${process.env.ACCESS_TOKEN}`,
+                },
+            });
+            expect(response.status()).toBe(204);
+        });
+    },
+});
+//# sourceMappingURL=index.js.map

package/fixtures/test/studio/index.d.ts

@@ -0,0 +1,17 @@
+export interface StudioFixtures {
+    /**
+     * Log into Appsemble studio as a user
+     *
+     * @param email Email address of the account to log in with
+     * @param password Password of the account
+     * @param saveInStorageState Whether or not to save the authenticated state as reusable storage
+     *   state (see: https://playwright.dev/docs/auth#basic-shared-account-in-all-tests)
+     * @returns The user's access token
+     */
+    loginUser: (email: string, password: string, saveInStorageState?: boolean) => Promise<string>;
+    /**
+     * Log the worker out of their current user account
+     */
+    logoutUser: () => Promise<void>;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & StudioFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;