Reactivate dashboard CI

.github/workflows/dashboard-src.yml

@@ -0,0 +1,81 @@
+# Workflow to run unit tests from Github Actions.
+# Inspired from: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: dashboard-src
+
+on:
+  push:
+    branches: [ master, develop ]
+  pull_request:
+    branches: [ master, develop ]
+  schedule:
+    - cron: '44 4 * * *'
+  release:
+    types: [published]
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: dashboard/src
+
+jobs:
+  test-dashboard-src:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x, 14.x, 16.x]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+      # Launch an orion server
+      - name: Launch Orion server
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - run: python -m pip install git+https://github.com/notoraptor/orion.git@feature/benchmark_webapi_rebased#egg=orion[profet]
+      - name: info about current directory
+        run: df .
+      - name: check filesystem type using df
+        run: df -Th
+      - name: check filesystem type using fstab
+        run: cat /etc/fstab
+
+      - name: Setup MongoDB
+        uses: supercharge/[email protected]
+        with:
+          mongodb-version: 4.2
+          mongodb-db: orion_dashboard_test
+      - name: Populate MongoDB
+        run: |
+            cd ../../
+            python .github/workflows/orion/pickle_to_mongodb.py
+            cd dashboard/src/
+
+      - name: Start Orion backend
+        run: |
+            # Start Orion backend in repository root folder.
+            cd ../../
+            mkdir -p gunicorn_tmp_dir
+            orion -vv serve -c .github/workflows/orion/orion_config_mongodb.yaml 2> orion-backend-${{ matrix.node-version }}.log &
+            cd dashboard/src/
+      # install
+      - run: yarn
+      # check files formatting using Carbon's `ci-check` script
+      - run: yarn ci-check
+      # Run tests
+      # NB: Tests are running in parallel by default, this may cause backend to receive too many requests in small time
+      # Option --runInBand allows running tests sequentially: https://jestjs.io/docs/cli#--runinband
+      - run: yarn test --all --verbose --runInBand
+      # Upload orion backend log.
+      - name: Get Orion backend log
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: orion-backend-log-artifact-${{ matrix.node-version }}
+          path: orion-backend-${{ matrix.node-version }}.log

.github/workflows/orion/orion_config.yaml

@@ -5,7 +5,10 @@ storage:
 
 gunicorn:
    bind: '127.0.0.1:8000'
-   workers: 4
-   threads: 2
+   workers: 1
+   threads: 1
+   timeout: 600
+   loglevel: 'debug'
+   worker_tmp_dir: gunicorn_tmp_dir
 
 frontends_uri: ["http://localhost:3000", "http://127.0.0.1:3000"]

.github/workflows/orion/orion_config_mongodb.yaml

@@ -0,0 +1,14 @@
+storage:
+  database:
+      name: 'orion_dashboard_test'
+      type: 'mongodb'
+
+gunicorn:
+   bind: '127.0.0.1:8000'
+   workers: 1
+   threads: 1
+   timeout: 600
+   loglevel: 'debug'
+   worker_tmp_dir: gunicorn_tmp_dir
+
+frontends_uri: ["http://localhost:3000", "http://127.0.0.1:3000"]

.github/workflows/orion/pickle_to_mongodb.py

@@ -0,0 +1,27 @@
+from orion.core.io.database.mongodb import MongoDB
+from orion.core.io.database.pickleddb import PickledDB
+from orion.storage.base import setup_storage
+
+
+def main():
+    storage = setup_storage(
+        {
+            "database": {
+                "host": ".github/workflows/orion/db_dashboard_full.pkl",
+                "type": "pickleddb",
+            }
+        }
+    )
+    pickle_db = storage._db
+    assert isinstance(pickle_db, PickledDB)
+    mongo_db = MongoDB(name="orion_dashboard_test")
+    with pickle_db.locked_database(write=False) as database:
+        for collection_name in database._db.keys():
+            print(f"[{collection_name}]")
+            data = database.read(collection_name)
+            mongo_db.write(collection_name, data)
+    print("Pickle to Mongo DB done.")
+
+
+if __name__ == "__main__":
+    main()

dashboard/src/package.json

@@ -40,10 +40,10 @@
   "devDependencies": {
     "@commitlint/cli": "17.0.1",
     "@commitlint/config-conventional": "7.6.0",
-    "@testing-library/dom": "^8.13.0",
-    "@testing-library/jest-dom": "^5.16.4",
-    "@testing-library/react": "^12.1.5",
-    "@testing-library/user-event": "^13.5.0",
+    "@testing-library/dom": "^8.17.1",
+    "@testing-library/jest-dom": "^5.16.5",
+    "@testing-library/react": "^13.4.0",
+    "@testing-library/user-event": "^14.4.3",
     "jest-canvas-mock": "^2.4.0",
     "lint-staged": "12.4.2",
     "prettier": "1.19.1",
@@ -89,5 +89,10 @@
     "singleQuote": true,
     "trailingComma": "es5"
   },
+  "jest": {
+    "transformIgnorePatterns": [
+      "/node_modules/(?!react-dnd|core-dnd|@react-dnd|dnd-core|react-dnd-html5-backend)"
+    ]
+  },
   "packageManager": "[email protected]"
 }

dashboard/src/src/__tests__/ExperimentNavBar.test.js

@@ -75,30 +75,31 @@ test('Check filter experiments with search field', async () => {
       else expect(domElement).toBeNull();
     }
   };
+  const user = userEvent.setup();
   render(<ExperimentNavBar />);
   const searchField = await screen.findByPlaceholderText('Search experiment');
   expect(searchField).toBeInTheDocument();
-  userEvent.type(searchField, 'random');
-  await waitFor(() => checkExpectations([0, 0, 0, 0, 1, 0, 0]), {
-    interval: 1000,
-    timeout: 120000,
-  });
-  userEvent.clear(searchField);
-  userEvent.type(searchField, 'rosenbrock');
-  await waitFor(() => checkExpectations([0, 0, 0, 0, 1, 1, 0]), {
-    interval: 1000,
-    timeout: 120000,
-  });
-  userEvent.clear(searchField);
-  userEvent.type(searchField, 'dim-cat');
-  await waitFor(() => checkExpectations([0, 1, 0, 1, 0, 0, 0]), {
-    interval: 1000,
-    timeout: 120000,
-  });
-  userEvent.clear(searchField);
-  userEvent.type(searchField, 'unknown experiment');
-  await waitFor(() => checkExpectations([0, 0, 0, 0, 0, 0, 0]), {
-    interval: 1000,
-    timeout: 120000,
-  });
+  await user.type(searchField, 'random');
+  await waitFor(
+    () => checkExpectations([0, 0, 0, 0, 1, 0, 0]),
+    global.CONFIG_WAIT_FOR_LONG
+  );
+  await user.clear(searchField);
+  await user.type(searchField, 'rosenbrock');
+  await waitFor(
+    () => checkExpectations([0, 0, 0, 0, 1, 1, 0]),
+    global.CONFIG_WAIT_FOR_LONG
+  );
+  await user.clear(searchField);
+  await user.type(searchField, 'dim-cat');
+  await waitFor(
+    () => checkExpectations([0, 1, 0, 1, 0, 0, 0]),
+    global.CONFIG_WAIT_FOR_LONG
+  );
+  await user.clear(searchField);
+  await user.type(searchField, 'unknown experiment');
+  await waitFor(
+    () => checkExpectations([0, 0, 0, 0, 0, 0, 0]),
+    global.CONFIG_WAIT_FOR_LONG
+  );
 });

dashboard/src/src/__tests__/VisualizationsPage.test.js

@@ -27,11 +27,7 @@ test('Test if we switch to visualization page', async () => {
   // Let time for ExperimentNavBar to load experiments
   // to prevent warnings about async calls not terminated
   expect(
-    await screen.findByText(
-      /2-dim-shape-exp/,
-      {},
-      { interval: 1000, timeout: 120000 }
-    )
+    await screen.findByText(/2-dim-shape-exp/, {}, global.CONFIG_WAIT_FOR_LONG)
   ).toBeInTheDocument();
 
   // Make sure we are on default (landing) page
@@ -58,7 +54,7 @@ test('Test if we can select and unselect experiments', async () => {
   const experiment = await screen.findByText(
     /2-dim-shape-exp/,
     {},
-    { interval: 1000, timeout: 120000 }
+    global.CONFIG_WAIT_FOR_LONG
   );
   expect(experiment).toBeInTheDocument();
 
@@ -73,14 +69,11 @@ test('Test if we can select and unselect experiments', async () => {
 
   // Check if plots are loaded
   // Wait enough (3 seconds) to let plots load
-  await waitFor(
-    () => {
-      expect(
-        screen.queryByText(/Regret for experiment '2-dim-shape-exp'/)
-      ).toBeInTheDocument();
-    },
-    { interval: 1000, timeout: 120000 }
-  );
+  await waitFor(() => {
+    expect(
+      screen.queryByText(/Regret for experiment '2-dim-shape-exp'/)
+    ).toBeInTheDocument();
+  }, global.CONFIG_WAIT_FOR_LONG);
   expect(
     await screen.findByText(
       /Parallel Coordinates PLot for experiment '2-dim-shape-exp'/i
@@ -108,14 +101,11 @@ test('Test if we can select and unselect experiments', async () => {
 
   // re-select experiment and check if plots are loaded
   fireEvent.click(experiment);
-  await waitFor(
-    () => {
-      expect(
-        screen.queryByText(/Regret for experiment '2-dim-shape-exp'/)
-      ).toBeInTheDocument();
-    },
-    { interval: 1000, timeout: 120000 }
-  );
+  await waitFor(() => {
+    expect(
+      screen.queryByText(/Regret for experiment '2-dim-shape-exp'/)
+    ).toBeInTheDocument();
+  }, global.CONFIG_WAIT_FOR_LONG);
   expect(
     await screen.findByText(
       /Parallel Coordinates PLot for experiment '2-dim-shape-exp'/i
@@ -129,14 +119,11 @@ test('Test if we can select and unselect experiments', async () => {
   const anotherExperiment = await screen.findByText(/tpe-rosenbrock/);
   expect(anotherExperiment).toBeInTheDocument();
   fireEvent.click(anotherExperiment);
-  await waitFor(
-    () => {
-      expect(
-        screen.queryByText(/Regret for experiment 'tpe-rosenbrock'/)
-      ).toBeInTheDocument();
-    },
-    { interval: 1000, timeout: 120000 }
-  );
+  await waitFor(() => {
+    expect(
+      screen.queryByText(/Regret for experiment 'tpe-rosenbrock'/)
+    ).toBeInTheDocument();
+  }, global.CONFIG_WAIT_FOR_LONG);
   expect(
     await screen.findByText(
       /Parallel Coordinates PLot for experiment 'tpe-rosenbrock'/i