Repository: jupyterlab/extension-examples (language: python)

Issue:
Add ui tests
Add playwright to test the examples

- Remaining examples:
  - [x] settings
  - [x] state
  - [x] toolbar-button
  - [x] widget
- [x] Tests on CI

This uncovers a bug in style packaging.  
This is using playwright test runner (no galata).

There are nice examples of playwright code for:
- capturing log console message (hello-world, settings,...), 
- capturing alert message (settings,...), 
- emulate drag and drop (move a panel in the main area to create a split panel) (kernel-output & log-messages).
- get `select` current value (state)
- wait for a request (state)

log console and alert dialogs are not capture when generating videos from tests. So it seems unappropriate to replace existing preview with those videos although they will allow to be up to date.

What do you think @jtpio @echarles?


Discussion / hints:
Thanks for starting this!

>  This is using playwright test runner (no galata).

This could be useful to lay the foundations for a potential rework in Galata discussed in https://github.com/jupyterlab/galata/issues/67

> So it seems unappropriate to replace existing preview with those videos although they will allow to be up to date.

Some time a while ago it was also discussed whether to check the screencasts in the repositories because of their size. Probably this will be a similar issue with videos?
> Probably this will be a similar issue with videos?

Yes. What I had in mind was to create a manual workflow (or one triggered by new JLab release) that would have open a PR to update those videos/screenshots only once in a while (with maybe a conversion to GIF and cutting the first few seconds corresponding to the logo animation for the videos).
The failure is on Mac and not related to this.
Probably this could fix https://github.com/jupyterlab/extension-examples/issues/45?

Or do we still want to have examples of setting up unit tests in this repo?
Also we might want to make the `ui-tests` more discoverable, for example by linking to the folder from the example README.md?

So folks interesting in this could learn how to set them up. This could be in the hello world example, or in a dedicated testing example.
I would rather create a dedicated example to talk about testing (addressing ui-tests and jest tests). But I want to work on galata to stabilize its usage with playwright before doing so.

I'll merge this one and open a PR to add a section about the tests in the README.

Fix patch:
diff --git a/README.md b/README.md
index af3da9e3..a3ce2177 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,34 @@
 [![Github Actions Status](https://github.com/jupyterlab/extension-examples/workflows/CI/badge.svg)](https://github.com/jupyterlab/extension-examples/actions?query=workflow%3ACI)
 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyterlab/extension-examples/master?urlpath=lab)
 
+1. [Goal](#tldr)
+2. [Develop by Examples](#develop-by-examples)
+   1. [Commands](#commands)
+   2. [Command Palette](#command-palette)
+   3. [Context Menu](#context-menu)
+   4. [Custom Log Console](#custom-log-console)
+   5. [Datagrid](#datagrid)
+   6. _[Hello World](#hello-world)_
+   7. [Kernel Messaging](#kernel-messaging)
+   8. [Kernel Output](#kernel-output)
+   9. [Launcher](#launcher)
+   10. [Log Messages](#log-messages)
+   11. [Main Menu](#main-menu)
+   12. [React Widget](#react-widget)
+   13. _[Server Hello World](#server-hello-world)_
+   14. [Settings](#settings)
+   15. [Signals](#signals)
+   16. [State](#state)
+   17. [Toolbar Item](#toolbar-item)
+   18. [Widgets](#widgets)
+3. [Prerequisites](#prerequisites)
+4. [Develop and Use the Examples](#develop-and-use-the-examples)
+5. [Test the Examples](#test-the-examples)
+6. [Install a Published Extension](#install-a-published-extension)
+7. [About JupyterLab](#about-jupyterlab)
+8. [Credits](#credits)
+9. [Community Guidelines and Code of Conduct](#community-guidelines-and-code-of-conduct)
+
 ## TL;DR
 
 The goal of this repository is to show how to develop extensions for [JupyterLab](https://github.com/jupyterlab/jupyterlab), presented as short tutorial series.
@@ -178,7 +206,7 @@ Use State persistence in an extension.
 
 [![State](state/preview.gif)](state)
 
-### [Toolbar item](toolbar-button)
+### [Toolbar Item](toolbar-button)
 
 Add a new button to the notebook toolbar.
 
@@ -275,6 +303,20 @@ and you can refresh your browser to see your changes.
 
 We are using [embedme](https://github.com/zakhenry/embedme) to embed code snippets into the markdown READMEs. If you make changes to the source code, ensure you update the README and run `jlpm embedme` from the root of the repository to regenerate the READMEs.
 
+## Test the Examples
+
+The examples are automatically tested for:
+
+- Homogeneous configuration:  
+  Configuration files are compared to the reference ones of the _hello-world_ example
+- TypeScript code lint
+- Installation in JupyterLab:  
+  The installation is checked by listing the installed extension and running JupyterLab with the helper `python -m jupyterlab.browser_check`
+- Integration test:  
+  Those tests are emulating user action in JupyterLab to check the extension is behaving as expected.  
+  The tests are defined in the `ui-tests` subfolder within each example.
+  This is possible thanks to a tool called [playwright](https://playwright.dev/).
+
 ## Install a Published Extension
 
 Once your extension is published on [pypi.org](https://pypi.org/) (outside of this scope), you can install it


Test patch:
diff --git a/command-palette/ui-tests/README.md b/command-palette/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/command-palette/ui-tests/README.md
+++ b/command-palette/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/commands/ui-tests/README.md b/commands/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/commands/ui-tests/README.md
+++ b/commands/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/context-menu/ui-tests/README.md b/context-menu/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/context-menu/ui-tests/README.md
+++ b/context-menu/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/custom-log-console/ui-tests/README.md b/custom-log-console/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/custom-log-console/ui-tests/README.md
+++ b/custom-log-console/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/datagrid/ui-tests/README.md b/datagrid/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/datagrid/ui-tests/README.md
+++ b/datagrid/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/hello-world/ui-tests/README.md b/hello-world/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/hello-world/ui-tests/README.md
+++ b/hello-world/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/kernel-messaging/ui-tests/README.md b/kernel-messaging/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/kernel-messaging/ui-tests/README.md
+++ b/kernel-messaging/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/kernel-output/ui-tests/README.md b/kernel-output/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/kernel-output/ui-tests/README.md
+++ b/kernel-output/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/launcher/ui-tests/README.md b/launcher/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/launcher/ui-tests/README.md
+++ b/launcher/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/log-messages/ui-tests/README.md b/log-messages/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/log-messages/ui-tests/README.md
+++ b/log-messages/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/main-menu/ui-tests/README.md b/main-menu/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/main-menu/ui-tests/README.md
+++ b/main-menu/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/react-widget/ui-tests/README.md b/react-widget/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/react-widget/ui-tests/README.md
+++ b/react-widget/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/server-extension/ui-tests/README.md b/server-extension/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/server-extension/ui-tests/README.md
+++ b/server-extension/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/settings/ui-tests/README.md b/settings/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/settings/ui-tests/README.md
+++ b/settings/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/signals/ui-tests/README.md b/signals/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/signals/ui-tests/README.md
+++ b/signals/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/state/ui-tests/README.md b/state/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/state/ui-tests/README.md
+++ b/state/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/toolbar-button/ui-tests/README.md b/toolbar-button/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/toolbar-button/ui-tests/README.md
+++ b/toolbar-button/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
diff --git a/widgets/ui-tests/README.md b/widgets/ui-tests/README.md
index 78aa707b..3b4d7d47 100644
--- a/widgets/ui-tests/README.md
+++ b/widgets/ui-tests/README.md
@@ -2,7 +2,7 @@
 
 The test will produce a video to help debugging and check what happened.
 
-To execute integration tests, you can two options:
+To execute integration tests, you have two options:
 
 - use docker-compose (cons: needs to know and use docker) - this is a more reliable solution.
 - run tests locally (cons: will interact with your JupyterLab user settings)
@@ -16,12 +16,12 @@ jlpm install
 jlpm run build:prod
 ```
 
-2. Execute the docker stack (`extension-path` needs to be set accordingly):
+2. Execute the docker stack in the example folder:
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env build
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm e2e
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env down
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env build
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm e2e
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env down
 ```
 
 ## Test locally
@@ -63,7 +63,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**
@@ -96,7 +96,7 @@ jlpm run build:prod
 **Using docker**
 
 ```
-docker-compose -f ./end-to-end-tests/docker-compose.yml --env-file ./extension-path/ui-tests/.env run --rm -p 8888:8888 lab
+docker-compose -f ../end-to-end-tests/docker-compose.yml --env-file ./ui-tests/.env run --rm -p 8888:8888 lab
 ```
 
 **Using local installation**