fix(executions): make state_duration generated on queries

- fixes https://github.com/kestra-io/kestra/issues/11593

.github/workflows/auto-translate-ui-keys.yml

@@ -0,0 +1,67 @@
+name: Auto-Translate UI keys and create PR
+
+on:
+  schedule:
+    - cron: "0 9-21/3 * * *"  # Every 3 hours from 9 AM to 9 PM
+  workflow_dispatch:
+    inputs:
+      retranslate_modified_keys:
+        description: "Whether to re-translate modified keys even if they already have translations."
+        type: choice
+        options:
+          - "false"
+          - "true"
+        default: "false"
+        required: false
+
+jobs:
+  translations:
+    name: Translations
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+        - uses: actions/checkout@v5
+          name: Checkout
+          with:
+            fetch-depth: 0
+
+        - name: Set up Python
+          uses: actions/setup-python@v6
+          with:
+            python-version: "3.x"
+
+        - name: Install Python dependencies
+          run: pip install gitpython openai
+
+        - name: Generate translations
+          run: python ui/src/translations/generate_translations.py ${{ github.event.inputs.retranslate_modified_keys }}
+          env:
+            OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+        - name: Set up Node
+          uses: actions/setup-node@v5
+          with:
+            node-version: "20.x"
+
+        - name: Set up Git
+          run: |
+            git config --global user.name "GitHub Action"
+            git config --global user.email "actions@github.com"
+
+        - name: Commit and create PR
+          env:
+            GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          run: |
+            BRANCH_NAME="chore/update-translations-$(date +%s)"
+            git checkout -b $BRANCH_NAME
+            git add ui/src/translations/*.json
+            if git diff --cached --quiet; then
+              echo "No changes to commit. Exiting with success."
+              exit 0
+            fi
+            git commit -m "chore(core): localize to languages other than english" -m "Extended localization support by adding translations for multiple languages using English as the base. This enhances accessibility and usability for non-English-speaking users while keeping English as the source reference."
+            git push -u origin $BRANCH_NAME || (git push origin --delete $BRANCH_NAME && git push -u origin $BRANCH_NAME)
+            gh pr create --title "Translations from en.json" --body $'This PR was created automatically by a GitHub Action.\n\nSomeone from the @kestra-io/frontend team needs to review and merge.' --base ${{ github.ref_name }} --head $BRANCH_NAME
+
+        - name: Check keys matching
+          run: node ui/src/translations/check.js

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,85 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+name: "CodeQL"
+
+on:
+  schedule:
+    - cron: '0 5 * * 1'
+
+  workflow_dispatch: {}
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
+        language: ['java', 'javascript']
+        # Learn more...
+        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v5
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # If this run was triggered by a pull request event, then checkout
+    # the head of the pull request instead of the merge commit.
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Set up JDK
+    - name: Set up JDK
+      uses: actions/setup-java@v5
+      if: ${{ matrix.language == 'java' }}
+      with:
+        distribution: 'temurin'
+        java-version: 21
+
+    - name: Setup gradle
+      if: ${{ matrix.language == 'java' }}
+      uses: gradle/actions/setup-gradle@v4
+
+    - name: Build with Gradle
+      if: ${{ matrix.language == 'java' }}
+      run: ./gradlew testClasses -x :ui:assembleFrontend
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      if: ${{ matrix.language != 'java' }}
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/e2e-scheduling.yml

@@ -0,0 +1,15 @@
+name: 'E2E tests scheduling'
+# 'New E2E tests implementation started by Roman. Based on playwright in npm UI project, tests Kestra OSS develop docker image. These tests are written from zero, lets make them unflaky from the start!.'
+on:
+  schedule:
+    - cron: "0 * * * *"  # Every hour
+  workflow_dispatch:
+    inputs:
+      noInputYet:
+        description: 'not input yet.'
+        required: false
+        type: string
+        default: "no input"
+jobs:
+  e2e:
+    uses: kestra-io/actions/.github/workflows/kestra-oss-e2e-tests.yml@main

.github/workflows/global-create-new-release-branch.yml

@@ -0,0 +1,84 @@
+name: Create new release branch
+run-name: "Create new release branch Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0)'
+        required: true
+        type: string
+      nextVersion:
+        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
+        required: true
+        type: string
+env:
+  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
+  NEXT_VERSION: "${{ github.event.inputs.nextVersion }}"
+jobs:
+  release:
+    name: Release Kestra
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/develop'
+    steps:
+      # Checks
+      - name: Check Inputs
+        run: |
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)\.0$"
+            exit 1
+          fi
+
+          if ! [[ "$NEXT_VERSION" =~ ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$ ]]; then
+            echo "Invalid next version. Must match regex: ^[0-9]+(\.[0-9]+)\.0-SNAPSHOT$"
+            exit 1;
+          fi
+      # Checkout
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          path: kestra
+
+      # Setup build
+      - uses: kestra-io/actions/composite/setup-build@main
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+          caches-enabled: true
+
+      - name: Configure Git
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Run Gradle Release
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          # Extract the major and minor versions
+          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
+          PUSH_RELEASE_BRANCH="releases/v${BASE_VERSION}.x"
+
+          cd kestra
+
+          # Create and push release branch
+          git checkout -b "$PUSH_RELEASE_BRANCH";
+          git push -u origin "$PUSH_RELEASE_BRANCH";
+
+          # Run gradle release
+          git checkout develop;
+
+          if [[ "$RELEASE_VERSION" == *"-SNAPSHOT" ]]; then
+            ./gradlew release -Prelease.useAutomaticVersion=true \
+            -Prelease.releaseVersion="${RELEASE_VERSION}" \
+            -Prelease.newVersion="${NEXT_VERSION}" \
+            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}" \
+            -Prelease.failOnSnapshotDependencies=false
+          else
+            ./gradlew release -Prelease.useAutomaticVersion=true \
+            -Prelease.releaseVersion="${RELEASE_VERSION}" \
+            -Prelease.newVersion="${NEXT_VERSION}" \
+            -Prelease.pushReleaseVersionBranch="${PUSH_RELEASE_BRANCH}"
+          fi

.github/workflows/global-gradle-release-plugins.yml

@@ -0,0 +1,74 @@
+name: Run Gradle Release for Kestra Plugins
+
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0)'
+        required: true
+        type: string
+      nextVersion:
+        description: 'The next version (e.g., 0.22.0-SNAPSHOT)'
+        required: true
+        type: string
+      dryRun:
+        description: 'Use DRY_RUN mode'
+        required: false
+        default: 'false'
+jobs:
+  release:
+    name: Release plugins
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Setup build
+      - uses: kestra-io/actions/composite/setup-build@main
+        id: build
+        with:
+          java-enabled: true
+          node-enabled: true
+          python-enabled: true
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      - name: 'Configure Git'
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Run Gradle Release
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/release-plugins.sh;
+
+          ./dev-tools/release-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --next-version=${{github.event.inputs.nextVersion}} \
+          --yes \
+           ${{ steps.plugins-list.outputs.repositories }}
+
+      - name: Run Gradle Release (DRY_RUN)
+        if: ${{ github.event.inputs.dryRun == 'true' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/release-plugins.sh;
+
+          ./dev-tools/release-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --next-version=${{github.event.inputs.nextVersion}} \
+          --dry-run \
+          --yes \
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/global-setversion-tag-plugins.yml

@@ -0,0 +1,60 @@
+name: Set Version and Tag Plugins
+
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.0)'
+        required: true
+        type: string
+      dryRun:
+        description: 'Use DRY_RUN mode'
+        required: false
+        default: 'false'
+jobs:
+  tag:
+    name: Release plugins
+    runs-on: ubuntu-latest
+    steps:
+      # Checkout
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Get Plugins List
+      - name: Get Plugins List
+        uses: kestra-io/actions/composite/kestra-oss/kestra-oss-plugins-list@main
+        id: plugins-list
+        with:
+          plugin-version: 'LATEST'
+
+      - name: 'Configure Git'
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Set Version and Tag Plugins
+        if: ${{ github.event.inputs.dryRun == 'false' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/setversion-tag-plugins.sh;
+
+          ./dev-tools/setversion-tag-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --yes \
+           ${{ steps.plugins-list.outputs.repositories }}
+
+      - name: Set Version and Tag Plugins (DRY_RUN)
+        if: ${{ github.event.inputs.dryRun == 'true' }}
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          chmod +x ./dev-tools/setversion-tag-plugins.sh;
+
+          ./dev-tools/setversion-tag-plugins.sh \
+          --release-version=${{github.event.inputs.releaseVersion}} \
+          --dry-run \
+          --yes \
+          ${{ steps.plugins-list.outputs.repositories }}

.github/workflows/global-start-release.yml

@@ -0,0 +1,65 @@
+name: Start release
+run-name: "Start release of Kestra ${{ github.event.inputs.releaseVersion }} 🚀"
+on:
+  workflow_dispatch:
+    inputs:
+      releaseVersion:
+        description: 'The release version (e.g., 0.21.1)'
+        required: true
+        type: string
+
+permissions:
+  contents: write
+
+env:
+  RELEASE_VERSION: "${{ github.event.inputs.releaseVersion }}"
+jobs:
+  release:
+    name: Release Kestra
+    runs-on: ubuntu-latest
+    steps:
+      - name: Parse and Check Inputs
+        id: parse-and-check-inputs
+        run: |
+          CURRENT_BRANCH="${{ github.ref_name }}"
+          if ! [[ "$CURRENT_BRANCH" == "develop" ]]; then
+            echo "You can only run this workflow on develop, but you ran it on $CURRENT_BRANCH"
+            exit 1
+          fi
+
+          if ! [[ "$RELEASE_VERSION" =~ ^[0-9]+(\.[0-9]+)(\.[0-9]+)(-rc[0-9])?(-SNAPSHOT)?$ ]]; then
+            echo "Invalid release version. Must match regex: ^[0-9]+(\.[0-9]+)(\.[0-9]+)-(rc[0-9])?(-SNAPSHOT)?$"
+            exit 1
+          fi
+
+          # Extract the major and minor versions
+          BASE_VERSION=$(echo "$RELEASE_VERSION" | sed -E 's/^([0-9]+\.[0-9]+)\..*/\1/')
+          RELEASE_BRANCH="releases/v${BASE_VERSION}.x"
+          echo "release_branch=${RELEASE_BRANCH}" >> $GITHUB_OUTPUT
+
+      # Checkout
+      - name: Checkout
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_PERSONAL_TOKEN }}
+          ref: ${{ steps.parse-and-check-inputs.outputs.release_branch }}
+
+      # Configure
+      - name: Git - Configure
+        run: |
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      # Execute
+      - name: Start release by updating version and pushing a new tag
+        env:
+          GITHUB_PAT: ${{ secrets.GH_PERSONAL_TOKEN }}
+        run: |
+          # Update version
+          sed -i "s/^version=.*/version=$RELEASE_VERSION/" ./gradle.properties
+          git add ./gradle.properties
+          git commit -m"chore(version): update to version '$RELEASE_VERSION'"
+          git push
+          git tag -a "v$RELEASE_VERSION" -m"v$RELEASE_VERSION"
+          git push --tags

.github/workflows/vulnerabilities-check.yml

@@ -22,11 +22,12 @@ jobs:
           fetch-depth: 0
 
       # Setup build
-      - uses: kestra-io/actions/composite/setup-build@main
+      - uses: ./actions/.github/actions/setup-build
         id: build
         with:
           java-enabled: true
           node-enabled: true
+          caches-enabled: true
 
       # Npm
       - name: Npm - Install
@@ -48,3 +49,77 @@ jobs:
         with:
           name: dependency-check-report
           path: build/reports/dependency-check-report.html
+
+  develop-image-check:
+    name: Image Check (develop)
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+      actions: read
+    steps:
+      # Checkout
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Setup build
+      - uses: kestra-io/actions/composite/setup-build@main
+        id: build
+        with:
+          java-enabled: false
+          node-enabled: false
+          caches-enabled: true
+
+      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
+      - name: Docker Vulnerabilities Check
+        uses: aquasecurity/trivy-action@0.33.1
+        with:
+          image-ref: kestra/kestra:develop
+          format: 'template'
+          template: '@/contrib/sarif.tpl'
+          severity: 'CRITICAL,HIGH'
+          output: 'trivy-results.sarif'
+          skip-dirs: /app/plugins
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: 'trivy-results.sarif'
+          category: docker-
+
+  latest-image-check:
+    name: Image Check (latest)
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+      actions: read
+    steps:
+      # Checkout
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Setup build
+      - uses: kestra-io/actions/composite/setup-build@main
+        id: build
+        with:
+          java-enabled: false
+          node-enabled: false
+
+      # Run Trivy image scan for Docker vulnerabilities, see https://github.com/aquasecurity/trivy-action
+      - name: Docker Vulnerabilities Check
+        uses: aquasecurity/trivy-action@0.33.1
+        with:
+          image-ref: kestra/kestra:latest
+          format: table
+          skip-dirs: /app/plugins
+          scanners: vuln
+          severity: 'CRITICAL,HIGH'
+          output: 'trivy-results.sarif'
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: 'trivy-results.sarif'

Dockerfile.pr

@@ -1,5 +1,4 @@
-ARG KESTRA_DOCKER_BASE_VERSION=develop
-FROM  kestra/kestra:$KESTRA_DOCKER_BASE_VERSION
+FROM  kestra/kestra:develop
 
 USER root
 

README.md

@@ -19,9 +19,12 @@
 <br />
 
 <p align="center">
-    <a href="https://x.com/kestra_io"><img height="25" src="https://kestra.io/twitter.svg" alt="X(formerly Twitter)" /></a> &nbsp;
-    <a href="https://www.linkedin.com/company/kestra/"><img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" /></a> &nbsp;
-<a href="https://www.youtube.com/@kestra-io"><img height="25" src="https://kestra.io/youtube.svg" alt="youtube" /></a> &nbsp;
+  <a href="https://twitter.com/kestra_io" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/twitter.svg" alt="twitter" width="35" height="25" /></a>
+  <a href="https://www.linkedin.com/company/kestra/" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/linkedin.svg" alt="linkedin" width="35" height="25" /></a> 
+  <a href="https://www.youtube.com/@kestra-io" style="margin: 0 10px;">
+        <img height="25" src="https://kestra.io/youtube.svg" alt="youtube" width="35" height="25" /></a>
 </p>
 
 <p align="center">
@@ -33,10 +36,10 @@
 
 <p align="center">
     <a href="https://go.kestra.io/video/product-overview" target="_blank">
-        <img src="https://kestra.io/startvideo.png" alt="Get started in 4 minutes with Kestra" width="640px" />
+        <img src="https://kestra.io/startvideo.png" alt="Get started in 3 minutes with Kestra" width="640px" />
     </a>
 </p>
-<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 4 minutes.</i></p>
+<p align="center" style="color:grey;"><i>Click on the image to learn how to get started with Kestra in 3 minutes.</i></p>
 
 
 ## 🌟 What is Kestra?

build.gradle

@@ -25,19 +25,19 @@ plugins {
     id 'jacoco-report-aggregation'
 
     // helper
-    id "com.github.ben-manes.versions" version "0.52.0"
+    id "com.github.ben-manes.versions" version "0.53.0"
 
     // front
     id 'com.github.node-gradle.node' version '7.1.0'
 
     // release
     id 'net.researchgate.release' version '3.1.0'
-    id "com.gorylenko.gradle-git-properties" version "2.5.2"
+    id "com.gorylenko.gradle-git-properties" version "2.5.3"
     id 'signing'
     id "com.vanniktech.maven.publish" version "0.34.0"
 
     // OWASP dependency check
-    id "org.owasp.dependencycheck" version "12.1.3" apply false
+    id "org.owasp.dependencycheck" version "12.1.5" apply false
 }
 
 idea {
@@ -168,8 +168,9 @@ allprojects {
 /**********************************************************************************************************************\
  * Test
  **********************************************************************************************************************/
-subprojects {
-    if (it.name != 'platform' && it.name != 'jmh-benchmarks') {
+subprojects {subProj ->
+
+    if (subProj.name != 'platform' && subProj.name != 'jmh-benchmarks') {
         apply plugin: "com.adarshr.test-logger"
 
         java {
@@ -205,59 +206,39 @@ subprojects {
             testImplementation 'org.assertj:assertj-core'
         }
 
-        def commonTestConfig = { Test t ->
-            // set Xmx for test workers
-            t.maxHeapSize = '4g'
-
-            // configure en_US default locale for tests
-            t.systemProperty 'user.language', 'en'
-            t.systemProperty 'user.country', 'US'
-
-            t.environment 'SECRET_MY_SECRET', "{\"secretKey\":\"secretValue\"}".bytes.encodeBase64().toString()
-            t.environment 'SECRET_NEW_LINE', "cGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2\nZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZl\neXJsb25n"
-            t.environment 'SECRET_WEBHOOK_KEY', "secretKey".bytes.encodeBase64().toString()
-            t.environment 'SECRET_NON_B64_SECRET', "some secret value"
-            t.environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
-            t.environment 'ENV_TEST1', "true"
-            t.environment 'ENV_TEST2', "Pass by env"
-
-        }
-
-        tasks.register('flakyTest', Test) { Test t ->
-            group = 'verification'
-            description = 'Runs tests tagged @Flaky but does not fail the build.'
-
-            useJUnitPlatform {
-                includeTags 'flaky'
-            }
-            ignoreFailures = true
-
-            reports {
-                junitXml.required = true
-                junitXml.outputPerTestCase = true
-                junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true
-                junitXml.outputLocation = layout.buildDirectory.dir("test-results/flakyTest")
-            }
-            commonTestConfig(t)
-
-        }
-
         test {
-            useJUnitPlatform {
-                excludeTags 'flaky'
-            }
+            useJUnitPlatform()
             reports {
                 junitXml.required = true
                 junitXml.outputPerTestCase = true
                 junitXml.mergeReruns = true
-                junitXml.includeSystemErrLog = true
+                junitXml.includeSystemErrLog = true;
                 junitXml.outputLocation = layout.buildDirectory.dir("test-results/test")
             }
-            commonTestConfig(it)
+
+            // set Xmx for test workers
+            maxHeapSize = '4g'
+
+            // configure en_US default locale for tests
+            systemProperty 'user.language', 'en'
+            systemProperty 'user.country', 'US'
+
+            environment 'SECRET_MY_SECRET', "{\"secretKey\":\"secretValue\"}".bytes.encodeBase64().toString()
+            environment 'SECRET_NEW_LINE', "cGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2\nZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZleXJsb25ncGFzc3dvcmR2ZXJ5dmVyeXZl\neXJsb25n"
+            environment 'SECRET_WEBHOOK_KEY', "secretKey".bytes.encodeBase64().toString()
+            environment 'SECRET_NON_B64_SECRET', "some secret value"
+            environment 'SECRET_PASSWORD', "cGFzc3dvcmQ="
+            environment 'ENV_TEST1', "true"
+            environment 'ENV_TEST2', "Pass by env"
 
 
-            finalizedBy(tasks.named('flakyTest'))
+            if (subProj.name == 'core' || subProj.name == 'jdbc-h2' || subProj.name == 'jdbc-mysql' || subProj.name == 'jdbc-postgres') {
+                // JUnit 5 parallel settings
+                systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'
+                systemProperty 'junit.jupiter.execution.parallel.mode.default', 'concurrent'
+                systemProperty 'junit.jupiter.execution.parallel.mode.classes.default', 'same_thread'
+                systemProperty 'junit.jupiter.execution.parallel.config.strategy', 'dynamic'
+            }
         }
 
         testlogger {

cli/build.gradle

@@ -40,5 +40,6 @@ dependencies {
     implementation project(":worker")
 
     //test
+    testImplementation project(':tests')
     testImplementation "org.wiremock:wiremock-jetty12"
 }

cli/src/main/java/io/kestra/cli/App.java

@@ -49,7 +49,7 @@ import java.util.concurrent.Callable;
 @Introspected
 public class App implements Callable<Integer> {
     public static void main(String[] args) {
-        execute(App.class, args);
+        execute(App.class, new String [] { Environment.CLI }, args);
     }
 
     @Override
@@ -57,13 +57,13 @@ public class App implements Callable<Integer> {
         return PicocliRunner.call(App.class, "--help");
     }
 
-    protected static void execute(Class<?> cls, String... args) {
+    protected static void execute(Class<?> cls, String[] environments, String... args) {
         // Log Bridge
         SLF4JBridgeHandler.removeHandlersForRootLogger();
         SLF4JBridgeHandler.install();
 
         // Init ApplicationContext
-        ApplicationContext applicationContext = App.applicationContext(cls, args);
+        ApplicationContext applicationContext = App.applicationContext(cls, environments, args);
 
         // Call Picocli command
         int exitCode = 0;
@@ -80,6 +80,7 @@ public class App implements Callable<Integer> {
         System.exit(Objects.requireNonNullElse(exitCode, 0));
     }
 
+
     /**
      * Create an {@link ApplicationContext} with additional properties based on configuration files (--config) and
      * forced Properties from current command.
@@ -88,12 +89,13 @@ public class App implements Callable<Integer> {
      * @return the application context created
      */
     protected static ApplicationContext applicationContext(Class<?> mainClass,
+                                                           String[] environments,
                                                            String[] args) {
 
         ApplicationContextBuilder builder = ApplicationContext
             .builder()
             .mainClass(mainClass)
-            .environments(Environment.CLI);
+            .environments(environments);
 
         CommandLine cmd = new CommandLine(mainClass, CommandLine.defaultFactory());
         continueOnParsingErrors(cmd);

cli/src/main/java/io/kestra/cli/commands/servers/AbstractServerCommand.java

@@ -2,19 +2,27 @@ package io.kestra.cli.commands.servers;
 
 import io.kestra.cli.AbstractCommand;
 import io.kestra.core.contexts.KestraContext;
-import jakarta.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
-abstract public class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
+@Slf4j
+public abstract class AbstractServerCommand extends AbstractCommand implements ServerCommandInterface {
     @CommandLine.Option(names = {"--port"}, description = "The port to bind")
     Integer serverPort;
 
     @Override
     public Integer call()  throws Exception {
+        log.info("Machine information: {} available cpu(s), {}MB max memory, Java version {}", Runtime.getRuntime().availableProcessors(), maxMemoryInMB(), Runtime.version());
+
         this.shutdownHook(true, () -> KestraContext.getContext().shutdown());
+
         return super.call();
     }
 
+    private long maxMemoryInMB() {
+        return Runtime.getRuntime().maxMemory() / 1024 / 1024;
+    }
+
     protected static int defaultWorkerThread() {
         return Runtime.getRuntime().availableProcessors() * 8;
     }

cli/src/main/java/io/kestra/cli/commands/sys/SubmitQueuedCommand.java

@@ -6,7 +6,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
 import io.kestra.core.runners.ExecutionQueued;
-import io.kestra.core.services.ConcurrencyLimitService;
 import io.kestra.jdbc.runner.AbstractJdbcExecutionQueuedStorage;
 import io.micronaut.context.ApplicationContext;
 import jakarta.inject.Inject;
@@ -16,6 +15,8 @@ import picocli.CommandLine;
 
 import java.util.Optional;
 
+import static io.kestra.core.utils.Rethrow.throwConsumer;
+
 @CommandLine.Command(
     name = "submit-queued-execution",
     description = {"Submit all queued execution to the executor",
@@ -48,11 +49,9 @@ public class SubmitQueuedCommand extends AbstractCommand {
         }
         else if (queueType.get().equals("postgres") || queueType.get().equals("mysql") || queueType.get().equals("h2")) {
             var executionQueuedStorage = applicationContext.getBean(AbstractJdbcExecutionQueuedStorage.class);
-            var concurrencyLimitService = applicationContext.getBean(ConcurrencyLimitService.class);
 
             for (ExecutionQueued queued : executionQueuedStorage.getAllForAllTenants()) {
-                Execution restart = concurrencyLimitService.unqueue(queued.getExecution(), State.Type.RUNNING);
-                executionQueue.emit(restart);
+                executionQueuedStorage.pop(queued.getTenantId(), queued.getNamespace(), queued.getFlowId(), throwConsumer(execution -> executionQueue.emit(execution.withState(State.Type.CREATED))));
                 cpt++;
             }
         }

cli/src/main/java/io/kestra/cli/services/FileChangedEventListener.java

@@ -262,6 +262,8 @@ public class FileChangedEventListener {
     }
 
     private String getTenantIdFromPath(Path path) {
+        // FIXME there is probably a bug here when a tenant has '_' in its name,
+        //  a valid tenant name is defined with following regex: "^[a-z0-9][a-z0-9_-]*"
         return path.getFileName().toString().split("_")[0];
     }
 }

cli/src/test/java/io/kestra/cli/AppTest.java

@@ -37,7 +37,7 @@ class AppTest {
 
         final String[] args = new String[]{"server", serverType, "--help"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, args)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, args)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(args);
 
             assertTrue(ctx.getProperty("kestra.server-type", ServerType.class).isEmpty());
@@ -52,7 +52,7 @@ class AppTest {
 
         final String[] argsWithMissingParams = new String[]{"flow", "namespace", "update"};
 
-        try (ApplicationContext ctx = App.applicationContext(App.class, argsWithMissingParams)) {
+        try (ApplicationContext ctx = App.applicationContext(App.class, new String [] { Environment.CLI }, argsWithMissingParams)) {
             new CommandLine(App.class, new MicronautFactory(ctx)).execute(argsWithMissingParams);
 
             assertThat(out.toString()).startsWith("Missing required parameters: ");

cli/src/test/java/io/kestra/cli/services/FileChangedEventListenerTest.java

@@ -1,14 +1,15 @@
 package io.kestra.cli.services;
 
+import io.kestra.core.junit.annotations.FlakyTest;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.GenericFlow;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.utils.Await;
+import io.kestra.core.utils.TestsUtils;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
 import jakarta.inject.Inject;
 import org.apache.commons.io.FileUtils;
 import org.junit.jupiter.api.*;
-import org.junitpioneer.jupiter.RetryingTest;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -18,8 +19,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
+import org.junitpioneer.jupiter.RetryingTest;
 
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.Rethrow.throwRunnable;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -57,10 +58,12 @@ class FileChangedEventListenerTest {
         }
     }
 
-    @RetryingTest(5) // Flaky on CI but always pass locally
+    @FlakyTest
+    @RetryingTest(2)
     void test() throws IOException, TimeoutException {
+        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getSimpleName(), "test");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "myflow").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a basic flow
         String flow = """
@@ -73,14 +76,14 @@ class FileChangedEventListenerTest {
                 message: Hello World! 🚀
             """;
 
-        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, flow);
+        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, flow);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), flow.getBytes());
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isPresent(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow myflow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").orElseThrow();
+        Flow myflow = flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").orElseThrow();
         assertThat(myflow.getTasks()).hasSize(1);
         assertThat(myflow.getTasks().getFirst().getId()).isEqualTo("hello");
         assertThat(myflow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -88,16 +91,18 @@ class FileChangedEventListenerTest {
         // delete the flow
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "myflow").isEmpty(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "myflow").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
     }
 
-    @RetryingTest(5) // Flaky on CI but always pass locally
+    @FlakyTest
+    @RetryingTest(2)
     void testWithPluginDefault() throws IOException, TimeoutException {
+        var tenant = TestsUtils.randomTenant(FileChangedEventListenerTest.class.getName(), "testWithPluginDefault");
         // remove the flow if it already exists
-        flowRepository.findByIdWithSource(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
+        flowRepository.findByIdWithSource(tenant, "io.kestra.tests.watch", "pluginDefault").ifPresent(flow -> flowRepository.delete(flow));
 
         // create a flow with plugin default
         String pluginDefault = """
@@ -113,14 +118,14 @@ class FileChangedEventListenerTest {
                 values:
                   message: Hello World!
             """;
-        GenericFlow genericFlow = GenericFlow.fromYaml(MAIN_TENANT, pluginDefault);
+        GenericFlow genericFlow = GenericFlow.fromYaml(tenant, pluginDefault);
         Files.write(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"), pluginDefault.getBytes());
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isPresent(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isPresent(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );
-        Flow pluginDefaultFlow = flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
+        Flow pluginDefaultFlow = flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").orElseThrow();
         assertThat(pluginDefaultFlow.getTasks()).hasSize(1);
         assertThat(pluginDefaultFlow.getTasks().getFirst().getId()).isEqualTo("helloWithDefault");
         assertThat(pluginDefaultFlow.getTasks().getFirst().getType()).isEqualTo("io.kestra.plugin.core.log.Log");
@@ -128,7 +133,7 @@ class FileChangedEventListenerTest {
         // delete both files
         Files.delete(Path.of(FILE_WATCH + "/" + genericFlow.uidWithoutRevision() + ".yaml"));
         Await.until(
-            () -> flowRepository.findById(MAIN_TENANT, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
+            () -> flowRepository.findById(tenant, "io.kestra.tests.watch", "pluginDefault").isEmpty(),
             Duration.ofMillis(100),
             Duration.ofSeconds(10)
         );

core/build.gradle

@@ -84,7 +84,7 @@ dependencies {
 
     testImplementation "org.testcontainers:testcontainers:1.21.3"
     testImplementation "org.testcontainers:junit-jupiter:1.21.3"
-    testImplementation "org.bouncycastle:bcpkix-jdk18on:1.81"
+    testImplementation "org.bouncycastle:bcpkix-jdk18on"
 
     testImplementation "org.wiremock:wiremock-jetty12"
 }

core/src/main/java/io/kestra/core/app/AppBlockInterface.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 /**
  * Top-level marker interface for Kestra's plugin of type App.
  */
@@ -20,6 +18,6 @@ public interface AppBlockInterface extends io.kestra.core.models.Plugin {
     )
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     String getType();
 }

core/src/main/java/io/kestra/core/app/AppPluginInterface.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 /**
  * Top-level marker interface for Kestra's plugin of type App.
  */
@@ -20,6 +18,6 @@ public interface AppPluginInterface extends io.kestra.core.models.Plugin {
     )
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     String getType();
 }

core/src/main/java/io/kestra/core/models/Label.java

@@ -6,6 +6,7 @@ import jakarta.annotation.Nullable;
 import jakarta.validation.constraints.NotEmpty;
 
 import java.util.*;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 @Schema(description = "A key/value pair that can be attached to a Flow or Execution. Labels are often used to organize and categorize objects.")
@@ -43,7 +44,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static Map<String, String> toMap(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyMap();
         return labels.stream()
-            .filter(label -> label.value() != null && label.key() != null)
+            .filter(label -> label.value() != null && !label.value().isEmpty() && label.key() != null && !label.key().isEmpty())
             // using an accumulator in case labels with the same key exists: the second is kept
             .collect(Collectors.toMap(Label::key, Label::value, (first, second) -> second, LinkedHashMap::new));
     }
@@ -58,6 +59,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
     public static List<Label> deduplicate(@Nullable List<Label> labels) {
         if (labels == null || labels.isEmpty()) return Collections.emptyList();
         return toMap(labels).entrySet().stream()
+            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .collect(Collectors.toCollection(ArrayList::new));
     }
@@ -72,6 +74,7 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         if (map == null || map.isEmpty()) return List.of();
         return map.entrySet()
             .stream()
+            .filter(getEntryNotEmptyPredicate())
             .map(entry -> new Label(entry.getKey(), entry.getValue()))
             .toList();
     }
@@ -90,4 +93,14 @@ public record Label(@NotEmpty String key, @NotEmpty String value) {
         }
         return map;
     }
+
+    /**
+     * Provides predicate for not empty entries.
+     *
+     * @return The non-empty filter
+     */
+    public static Predicate<Map.Entry<String, String>> getEntryNotEmptyPredicate() {
+        return entry -> entry.getKey() != null && !entry.getKey().isEmpty() &&
+            entry.getValue() != null && !entry.getValue().isEmpty();
+    }
 }

core/src/main/java/io/kestra/core/models/PluginVersioning.java

@@ -1,16 +1,33 @@
 package io.kestra.core.models;
 
 import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.Valid;
 import jakarta.validation.constraints.Pattern;
 
+import java.util.List;
+import java.util.Map;
+
 /**
  * Interface that can be implemented by classes supporting plugin versioning.
  *
  * @see Plugin
  */
 public interface PluginVersioning {
+    
+    String TITLE = "Plugin Version";
+    String DESCRIPTION = """
+    Defines the version of the plugin to use.
 
-    @Pattern(regexp="\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9-]+)?|([a-zA-Z0-9]+)")
-    @Schema(title = "The version of the plugin to use.")
+    The version must follow the Semantic Versioning (SemVer) specification:
+      - A single-digit MAJOR version (e.g., `1`).
+      - A MAJOR.MINOR version (e.g., `1.1`).
+      - A MAJOR.MINOR.PATCH version, optionally with any qualifier
+        (e.g., `1.1.2`, `1.1.0-SNAPSHOT`).
+    """;
+    
+    @Schema(
+        title = TITLE,
+        description = DESCRIPTION
+    )
     String getVersion();
 }

core/src/main/java/io/kestra/core/models/QueryFilter.java

@@ -254,19 +254,7 @@ public record QueryFilter(
          *
          * @return List of {@code ResourceField} with resource names, fields, and operations.
          */
-        public static List<ResourceField> asResourceList() {
-            return Arrays.stream(values())
-                .map(Resource::toResourceField)
-                .toList();
-        }
-
-        private static ResourceField toResourceField(Resource resource) {
-            List<FieldOp> fieldOps = resource.supportedField().stream()
-                .map(Resource::toFieldInfo)
-                .toList();
-            return new ResourceField(resource.name().toLowerCase(), fieldOps);
-        }
-
+        
         private static FieldOp toFieldInfo(Field field) {
             List<Operation> operations = field.supportedOp().stream()
                 .map(Resource::toOperation)
@@ -279,9 +267,6 @@ public record QueryFilter(
         }
     }
 
-    public record ResourceField(String name, List<FieldOp> fields) {
-    }
-
     public record FieldOp(String name, String value, List<Operation> operations) {
     }
 

core/src/main/java/io/kestra/core/models/collectors/ExecutionUsage.java

@@ -17,31 +17,12 @@ import java.util.List;
 @Introspected
 public class ExecutionUsage {
     private final List<DailyExecutionStatistics> dailyExecutionsCount;
-    private final List<DailyExecutionStatistics> dailyTaskRunsCount;
 
     public static ExecutionUsage of(final String tenantId,
                                     final ExecutionRepositoryInterface executionRepository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
 
-        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
-
-        try {
-            dailyTaskRunsCount = executionRepository.dailyStatistics(
-                null,
-                tenantId,
-                null,
-                null,
-                null,
-                from,
-                to,
-                DateUtils.GroupType.DAY,
-                null,
-                true);
-        } catch (UnsupportedOperationException ignored) {
-
-        }
-
         return ExecutionUsage.builder()
             .dailyExecutionsCount(executionRepository.dailyStatistics(
                 null,
@@ -52,28 +33,13 @@ public class ExecutionUsage {
                 from,
                 to,
                 DateUtils.GroupType.DAY,
-                null,
-                false))
-            .dailyTaskRunsCount(dailyTaskRunsCount)
+                null))
             .build();
     }
 
     public static ExecutionUsage of(final ExecutionRepositoryInterface repository,
                                     final ZonedDateTime from,
                                     final ZonedDateTime to) {
-        List<DailyExecutionStatistics> dailyTaskRunsCount = null;
-        try {
-            dailyTaskRunsCount = repository.dailyStatisticsForAllTenants(
-                null,
-                null,
-                null,
-                from,
-                to,
-                DateUtils.GroupType.DAY,
-                true
-            );
-        } catch (UnsupportedOperationException ignored) {}
-
         return ExecutionUsage.builder()
             .dailyExecutionsCount(repository.dailyStatisticsForAllTenants(
                 null,
@@ -81,10 +47,8 @@ public class ExecutionUsage {
                 null,
                 from,
                 to,
-                DateUtils.GroupType.DAY,
-                false
+                DateUtils.GroupType.DAY
             ))
-            .dailyTaskRunsCount(dailyTaskRunsCount)
             .build();
     }
 }

core/src/main/java/io/kestra/core/models/conditions/Condition.java

@@ -12,8 +12,6 @@ import lombok.experimental.SuperBuilder;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @io.kestra.core.models.annotations.Plugin
 @SuperBuilder
 @Getter
@@ -22,6 +20,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public abstract class Condition implements Plugin, Rethrow.PredicateChecked<ConditionContext, InternalException> {
     @NotNull
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 }

core/src/main/java/io/kestra/core/models/dashboards/DataFilter.java

@@ -20,8 +20,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -30,7 +28,7 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class DataFilter<F extends Enum<F>, C extends ColumnDescriptor<F>> implements io.kestra.core.models.Plugin, IData<F> {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 
     private Map<String, C> columns;

core/src/main/java/io/kestra/core/models/dashboards/DataFilterKPI.java

@@ -19,8 +19,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -29,7 +27,7 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class DataFilterKPI<F extends Enum<F>, C extends ColumnDescriptor<F>> implements io.kestra.core.models.Plugin, IData<F> {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 
     private C columns;

core/src/main/java/io/kestra/core/models/dashboards/charts/Chart.java

@@ -12,8 +12,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @SuperBuilder(toBuilder = true)
 @Getter
 @NoArgsConstructor
@@ -28,7 +26,7 @@ public abstract class Chart<P extends ChartOption> implements io.kestra.core.mod
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     @Valid

core/src/main/java/io/kestra/core/models/executions/Execution.java

@@ -865,20 +865,18 @@ public class Execution implements DeletedInterface, TenantInterface {
      * @param e the exception raise
      * @return new taskRun with updated attempt with logs
      */
-    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun,
-        TaskRunAttempt lastAttempt, Exception e) {
+    private FailedTaskRunWithLog lastAttemptsTaskRunForFailedExecution(TaskRun taskRun, TaskRunAttempt lastAttempt, Exception e) {
+        TaskRun failed = taskRun
+            .withAttempts(
+                Stream
+                    .concat(
+                        taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
+                        Stream.of(lastAttempt.getState().isFailed() ? lastAttempt : lastAttempt.withState(State.Type.FAILED))
+                    )
+                    .toList()
+            );
         return new FailedTaskRunWithLog(
-            taskRun
-                .withAttempts(
-                    Stream
-                        .concat(
-                            taskRun.getAttempts().stream().limit(taskRun.getAttempts().size() - 1),
-                            Stream.of(lastAttempt
-                                .withState(State.Type.FAILED))
-                        )
-                        .toList()
-                )
-                .withState(State.Type.FAILED),
+            failed.getState().isFailed() ? failed : failed.withState(State.Type.FAILED),
             RunContextLogger.logEntries(loggingEventFromException(e), LogEntry.of(taskRun, kind))
         );
     }

core/src/main/java/io/kestra/core/models/executions/TaskRun.java

@@ -52,7 +52,6 @@ public class TaskRun implements TenantInterface {
 
     @With
     @JsonInclude(JsonInclude.Include.ALWAYS)
-    @Nullable
     Variables outputs;
 
     @NotNull
@@ -65,6 +64,7 @@ public class TaskRun implements TenantInterface {
     Boolean dynamic;
 
     // Set it to true to force execution even if the execution is killed
+    @Nullable
     @With
     Boolean forceExecution;
 
@@ -217,7 +217,7 @@ public class TaskRun implements TenantInterface {
     public boolean isSame(TaskRun taskRun) {
         return this.getId().equals(taskRun.getId()) &&
             ((this.getValue() == null && taskRun.getValue() == null) || (this.getValue() != null && this.getValue().equals(taskRun.getValue()))) &&
-            ((this.getIteration() == null && taskRun.getIteration() == null) || (this.getIteration() != null && this.getIteration().equals(taskRun.getIteration())));
+            ((this.getIteration() == null && taskRun.getIteration() == null) || (this.getIteration() != null && this.getIteration().equals(taskRun.getIteration()))) ;
     }
 
     public String toString(boolean pretty) {
@@ -249,7 +249,7 @@ public class TaskRun implements TenantInterface {
      * This method is used when the retry is apply on a task
      * but the retry type is NEW_EXECUTION
      *
-     * @param retry     Contains the retry configuration
+     * @param retry Contains the retry configuration
      * @param execution Contains the attempt number and original creation date
      * @return The next retry date, null if maxAttempt || maxDuration is reached
      */
@@ -270,7 +270,6 @@ public class TaskRun implements TenantInterface {
 
     /**
      * This method is used when the Retry definition comes from the flow
-     *
      * @param retry The retry configuration
      * @return The next retry date, null if maxAttempt || maxDuration is reached
      */
@@ -297,7 +296,7 @@ public class TaskRun implements TenantInterface {
     }
 
     public TaskRun incrementIteration() {
-        int iteration = this.iteration == null ? 1 : this.iteration;
+        int iteration = this.iteration == null ? 0 : this.iteration;
         return this.toBuilder()
             .iteration(iteration + 1)
             .build();

core/src/main/java/io/kestra/core/models/flows/AbstractFlow.java

@@ -61,22 +61,18 @@ public abstract class AbstractFlow implements FlowInterface {
     @JsonSerialize(using = ListOrMapOfLabelSerializer.class)
     @JsonDeserialize(using = ListOrMapOfLabelDeserializer.class)
     @Schema(
-        description = "Labels as a list of Label (key/value pairs) or as a map of string to string.",
-        oneOf = {
-            Label[].class,
-            Map.class
-        }
+            description = "Labels as a list of Label (key/value pairs) or as a map of string to string.",
+            oneOf = {
+                    Label[].class,
+                    Map.class
+            }
     )
     @Valid
     List<Label> labels;
 
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
+    @Schema(additionalProperties = Schema.AdditionalPropertiesValue.TRUE)
     Map<String, Object> variables;
 
-
     @Valid
     private WorkerGroup workerGroup;
 

core/src/main/java/io/kestra/core/models/flows/Flow.java

@@ -61,11 +61,6 @@ public class Flow extends AbstractFlow implements HasUID {
             }
         });
 
-
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
     Map<String, Object> variables;
 
     @Valid

core/src/main/java/io/kestra/core/models/flows/Input.java

@@ -5,6 +5,7 @@ import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import io.kestra.core.models.flows.input.*;
 import io.kestra.core.models.property.Property;
+import io.kestra.core.runners.RunContext;
 import io.micronaut.core.annotation.Introspected;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.ConstraintViolationException;
@@ -17,6 +18,8 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
+import java.util.function.Function;
+
 @SuppressWarnings("deprecation")
 @SuperBuilder
 @Getter

core/src/main/java/io/kestra/core/models/flows/Output.java

@@ -1,7 +1,6 @@
 package io.kestra.core.models.flows;
 
 import io.micronaut.core.annotation.Introspected;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.Valid;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
@@ -34,12 +33,6 @@ public class Output implements Data {
      * The output value. Can be a dynamic expression.
      */
     @NotNull
-    @Schema(
-        oneOf = {
-            Object.class,
-            String.class
-        }
-    )
     Object value;
 
     /**

core/src/main/java/io/kestra/core/models/flows/PluginDefault.java

@@ -2,7 +2,6 @@ package io.kestra.core.models.flows;
 
 import io.kestra.core.validations.PluginDefaultValidation;
 import io.micronaut.core.annotation.Introspected;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -22,10 +21,6 @@ public class PluginDefault {
     @Builder.Default
     private final boolean forced = false;
 
-    @Schema(
-        type = "object",
-        additionalProperties = Schema.AdditionalPropertiesValue.FALSE
-    )
     private final Map<String, Object> values;
 }
 

core/src/main/java/io/kestra/core/models/flows/State.java

@@ -86,10 +86,11 @@ public class State {
 
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)
     public Duration getDuration() {
-        return Duration.between(
-            this.histories.getFirst().getDate(),
-            this.histories.size() > 1 ? this.histories.get(this.histories.size() - 1).getDate() : Instant.now()
-        );
+        if(this.getEndDate().isPresent()){
+            return Duration.between(this.getStartDate(), this.getEndDate().get());
+        } else {
+            return Duration.between(this.getStartDate(), Instant.now());
+        }
     }
 
     @JsonProperty(access = JsonProperty.Access.READ_ONLY)

core/src/main/java/io/kestra/core/models/property/Property.java

@@ -12,7 +12,6 @@ import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.serializers.JacksonMapper;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
@@ -37,12 +36,6 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
 @Builder
 @NoArgsConstructor
 @AllArgsConstructor(access = AccessLevel.PACKAGE)
-@Schema(
-    oneOf = {
-        Object.class,
-        String.class
-    }
-)
 public class Property<T> {
     // By default, durations are stored as numbers.
     // We cannot change that globally, as in JDBC/Elastic 'execution.state.duration' must be a number to be able to aggregate them.
@@ -75,7 +68,7 @@ public class Property<T> {
     String getExpression() {
         return expression;
     }
-
+    
     /**
      * Returns a new {@link Property} with no cached rendered value,
      * so that the next render will evaluate its original Pebble expression.
@@ -91,9 +84,9 @@ public class Property<T> {
 
     /**
      * Build a new Property object with a value already set.<br>
-     * <p>
+     *
      * A property build with this method will always return the value passed at build time, no rendering will be done.
-     * <p>
+     *
      * Use {@link #ofExpression(String)} to build a property with a Pebble expression instead.
      */
     public static <V> Property<V> ofValue(V value) {
@@ -133,12 +126,12 @@ public class Property<T> {
 
     /**
      * Build a new Property object with a Pebble expression.<br>
-     * <p>
+     *
      * Use {@link #ofValue(Object)} to build a property with a value instead.
      */
     public static <V> Property<V> ofExpression(@NotNull String expression) {
         Objects.requireNonNull(expression, "'expression' is required");
-        if (!expression.contains("{")) {
+        if(!expression.contains("{")) {
             throw new IllegalArgumentException("'expression' must be a valid Pebble expression");
         }
 
@@ -147,7 +140,7 @@ public class Property<T> {
 
     /**
      * Render a property then convert it to its target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#as(Class)
@@ -158,14 +151,14 @@ public class Property<T> {
 
     /**
      * Render a property with additional variables, then convert it to its target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#as(Class, Map)
      */
     public static <T> T as(Property<T> property, PropertyContext context, Class<T> clazz, Map<String, Object> variables) throws IllegalVariableEvaluationException {
         if (property.value == null) {
-            String rendered = context.render(property.expression, variables);
+            String rendered =  context.render(property.expression, variables);
             property.value = MAPPER.convertValue(rendered, clazz);
         }
 
@@ -174,7 +167,7 @@ public class Property<T> {
 
     /**
      * Render a property then convert it as a list of target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asList(Class)
@@ -185,7 +178,7 @@ public class Property<T> {
 
     /**
      * Render a property with additional variables, then convert it as a list of target type.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asList(Class, Map)
@@ -225,25 +218,25 @@ public class Property<T> {
 
     /**
      * Render a property then convert it as a map of target types.<br>
-     * <p>
+     *
      * This method is designed to be used only by the {@link io.kestra.core.runners.RunContextProperty}.
      *
      * @see io.kestra.core.runners.RunContextProperty#asMap(Class, Class)
      */
-    public static <T, K, V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass) throws IllegalVariableEvaluationException {
+    public static <T, K,V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass) throws IllegalVariableEvaluationException {
         return asMap(property, runContext, keyClass, valueClass, Map.of());
     }
 
     /**
      * Render a property with additional variables, then convert it as a map of target types.<br>
-     * <p>
+     *
      * This method is safe to be used as many times as you want as the rendering and conversion will be cached.
      * Warning, due to the caching mechanism, this method is not thread-safe.
      *
      * @see io.kestra.core.runners.RunContextProperty#asMap(Class, Class, Map)
      */
     @SuppressWarnings({"rawtypes", "unchecked"})
-    public static <T, K, V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass, Map<String, Object> variables) throws IllegalVariableEvaluationException {
+    public static <T, K,V> T asMap(Property<T> property, RunContext runContext, Class<K> keyClass, Class<V> valueClass, Map<String, Object> variables) throws IllegalVariableEvaluationException {
         if (property.value == null) {
             JavaType targetMapType = MAPPER.getTypeFactory().constructMapType(Map.class, keyClass, valueClass);
 

core/src/main/java/io/kestra/core/models/tasks/ResolvedTask.java

@@ -30,7 +30,7 @@ public class ResolvedTask {
 
     public NextTaskRun toNextTaskRunIncrementIteration(Execution execution, Integer iteration) {
         return new NextTaskRun(
-            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 1),
+            TaskRun.of(execution, this).withIteration(iteration != null ? iteration : 0),
             this.getTask()
         );
     }

core/src/main/java/io/kestra/core/models/tasks/TaskInterface.java

@@ -8,8 +8,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public interface TaskInterface extends Plugin, PluginVersioning {
     @NotNull
@@ -19,7 +17,7 @@ public interface TaskInterface extends Plugin, PluginVersioning {
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     @Schema(title = "The class name of this task.")
     String getType();
 }

core/src/main/java/io/kestra/core/models/tasks/logs/LogExporter.java

@@ -11,8 +11,6 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 import reactor.core.publisher.Flux;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @Plugin
 @SuperBuilder(toBuilder = true)
 @Getter
@@ -24,7 +22,7 @@ public abstract class LogExporter<T extends Output>  implements io.kestra.core.m
     protected String id;
 
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     public abstract T sendLogs(RunContext runContext, Flux<LogRecord> logRecords) throws Exception;

core/src/main/java/io/kestra/core/models/tasks/runners/RemoteRunnerInterface.java

@@ -1,11 +1,3 @@
 package io.kestra.core.models.tasks.runners;
 
-import io.kestra.core.models.property.Property;
-import io.swagger.v3.oas.annotations.media.Schema;
-
-public interface RemoteRunnerInterface {
-    @Schema(
-        title = "Whether to synchronize working directory from remote runner back to local one after run."
-    )
-    Property<Boolean> getSyncWorkingDirectory();
-}
+public interface RemoteRunnerInterface {}

core/src/main/java/io/kestra/core/models/tasks/runners/TaskCommands.java

@@ -30,10 +30,6 @@ public interface TaskCommands {
 
     Map<String, Object> getAdditionalVars();
 
-    default String outputDirectoryName() {
-        return this.getWorkingDirectory().relativize(this.getOutputDirectory()).toString();
-    }
-
     Path getWorkingDirectory();
 
     Path getOutputDirectory();

core/src/main/java/io/kestra/core/models/tasks/runners/TaskRunner.java

@@ -7,6 +7,7 @@ import io.kestra.core.models.Plugin;
 import io.kestra.core.models.PluginVersioning;
 import io.kestra.core.models.WorkerJobLifecycle;
 import io.kestra.core.models.annotations.PluginProperty;
+import io.kestra.core.models.property.Property;
 import io.kestra.core.runners.RunContext;
 import io.kestra.plugin.core.runner.Process;
 import jakarta.validation.constraints.NotBlank;
@@ -18,14 +19,13 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 import org.apache.commons.lang3.SystemUtils;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.io.IOException;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Stream;
 
 import static io.kestra.core.utils.WindowsUtils.windowsToUnixPath;
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 
 /**
  * Base class for all task runners.
@@ -37,7 +37,7 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 @JsonInclude(JsonInclude.Include.NON_DEFAULT)
 public abstract class TaskRunner<T extends TaskRunnerDetailResult> implements Plugin, PluginVersioning, WorkerJobLifecycle {
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 
     @PluginProperty(hidden = true, group = PluginProperty.CORE_GROUP)

core/src/main/java/io/kestra/core/models/triggers/AbstractTrigger.java

@@ -50,7 +50,6 @@ abstract public class AbstractTrigger implements TriggerInterface {
     @NotNull
     @Builder.Default
     @PluginProperty(hidden = true, group = PluginProperty.CORE_GROUP)
-    @Schema(defaultValue = "false")
     private boolean disabled = false;
 
     @Valid

core/src/main/java/io/kestra/core/models/triggers/TriggerContext.java

@@ -4,7 +4,6 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.core.annotation.Introspected;
 import io.micronaut.core.annotation.Nullable;
-import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 import lombok.Getter;
@@ -47,7 +46,6 @@ public class TriggerContext {
     @Nullable
     private List<State.Type> stopAfter;
 
-    @Schema(defaultValue = "false")
     private Boolean disabled = Boolean.FALSE;
 
     protected TriggerContext(TriggerContextBuilder<?, ?> b) {

core/src/main/java/io/kestra/core/models/triggers/TriggerInterface.java

@@ -7,7 +7,6 @@ import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 
 public interface TriggerInterface extends Plugin, PluginVersioning {
     @NotNull
@@ -18,7 +17,7 @@ public interface TriggerInterface extends Plugin, PluginVersioning {
 
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     @Schema(title = "The class name for this current trigger.")
     String getType();
 

core/src/main/java/io/kestra/core/plugins/AdditionalPlugin.java

@@ -8,8 +8,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @io.kestra.core.models.annotations.Plugin
 @SuperBuilder(toBuilder = true)
 @Getter
@@ -17,6 +15,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public abstract class AdditionalPlugin implements Plugin {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp="\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     protected String type;
 }

core/src/main/java/io/kestra/core/plugins/DefaultPluginRegistry.java

@@ -56,7 +56,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
      *
      * @return the {@link DefaultPluginRegistry}.
      */
-    public static DefaultPluginRegistry getOrCreate() {
+    public synchronized static DefaultPluginRegistry getOrCreate() {
         DefaultPluginRegistry instance = LazyHolder.INSTANCE;
         if (!instance.isInitialized()) {
             instance.init();
@@ -74,7 +74,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
     /**
      * Initializes the registry by loading all core plugins.
      */
-    protected void init() {
+    protected synchronized void init() {
         if (initialized.compareAndSet(false, true)) {
             register(scanner.scan());
         }
@@ -200,7 +200,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
         if (existing != null && existing.crc32() == plugin.crc32()) {
             return; // same plugin already registered
         }
-        
+
         lock.lock();
         try {
             if (existing != null) {
@@ -212,7 +212,7 @@ public class DefaultPluginRegistry implements PluginRegistry {
             lock.unlock();
         }
     }
-    
+
     protected void registerAll(Map<PluginIdentifier, PluginClassAndMetadata<? extends Plugin>> plugins) {
         pluginClassByIdentifier.putAll(plugins);
     }

core/src/main/java/io/kestra/core/plugins/serdes/PluginDeserializer.java

@@ -144,7 +144,7 @@ public final class PluginDeserializer<T extends Plugin> extends JsonDeserializer
 
     static String extractPluginRawIdentifier(final JsonNode node, final boolean isVersioningSupported) {
         String type = Optional.ofNullable(node.get(TYPE)).map(JsonNode::textValue).orElse(null);
-        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::textValue).orElse(null);
+        String version = Optional.ofNullable(node.get(VERSION)).map(JsonNode::asText).orElse(null);
 
         if (type == null || type.isEmpty()) {
             return null;

core/src/main/java/io/kestra/core/queues/QueueFactoryInterface.java

@@ -26,6 +26,7 @@ public interface QueueFactoryInterface {
     String SUBFLOWEXECUTIONRESULT_NAMED = "subflowExecutionResultQueue";
     String CLUSTER_EVENT_NAMED = "clusterEventQueue";
     String SUBFLOWEXECUTIONEND_NAMED = "subflowExecutionEndQueue";
+    String EXECUTION_RUNNING_NAMED = "executionRunningQueue";
     String MULTIPLE_CONDITION_EVENT_NAMED = "multipleConditionEventQueue";
 
     QueueInterface<Execution> execution();
@@ -58,5 +59,7 @@ public interface QueueFactoryInterface {
 
     QueueInterface<SubflowExecutionEnd> subflowExecutionEnd();
 
+    QueueInterface<ExecutionRunning> executionRunning();
+
     QueueInterface<MultipleConditionEvent> multipleConditionEvent();
 }

core/src/main/java/io/kestra/core/repositories/ExecutionRepositoryInterface.java

@@ -25,8 +25,6 @@ import java.util.Optional;
 import java.util.function.Function;
 
 public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Execution>, QueryBuilderInterface<Executions.Fields> {
-    Boolean isTaskRunEnabled();
-
     default Optional<Execution> findById(String tenantId, String id) {
         return findById(tenantId, id, false);
     }
@@ -96,12 +94,6 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
 
     Flux<Execution> findAllAsync(@Nullable String tenantId);
 
-    ArrayListTotal<TaskRun> findTaskRun(
-        Pageable pageable,
-        @Nullable String tenantId,
-        List<QueryFilter> filters
-    );
-
     Execution delete(Execution execution);
 
     Integer purge(Execution execution);
@@ -114,8 +106,7 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable String flowId,
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
-        @Nullable DateUtils.GroupType groupBy,
-        boolean isTaskRun
+        @Nullable DateUtils.GroupType groupBy
     );
 
     List<DailyExecutionStatistics> dailyStatistics(
@@ -127,8 +118,7 @@ public interface ExecutionRepositoryInterface extends SaveRepositoryInterface<Ex
         @Nullable ZonedDateTime startDate,
         @Nullable ZonedDateTime endDate,
         @Nullable DateUtils.GroupType groupBy,
-        List<State.Type> state,
-        boolean isTaskRun
+        List<State.Type> state
     );
 
     @Getter

core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java

@@ -4,6 +4,7 @@ import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.SearchResult;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.*;
+import io.kestra.plugin.core.dashboard.data.Flows;
 import io.micronaut.data.model.Pageable;
 import jakarta.annotation.Nullable;
 import jakarta.validation.ConstraintViolationException;
@@ -11,7 +12,7 @@ import jakarta.validation.ConstraintViolationException;
 import java.util.List;
 import java.util.Optional;
 
-public interface FlowRepositoryInterface {
+public interface FlowRepositoryInterface extends QueryBuilderInterface<Flows.Fields> {
 
     Optional<Flow> findById(String tenantId, String namespace, String id, Optional<Integer> revision, Boolean allowDeleted);
 
@@ -25,8 +26,8 @@ public interface FlowRepositoryInterface {
      * Used only if result is used internally and not exposed to the user.
      * It is useful when we want to restart/resume a flow.
      */
-    default FlowWithSource findByExecutionWithoutAcl(Execution execution) {
-        Optional<FlowWithSource> find = this.findByIdWithSourceWithoutAcl(
+    default Flow findByExecutionWithoutAcl(Execution execution) {
+        Optional<Flow> find = this.findByIdWithoutAcl(
             execution.getTenantId(),
             execution.getNamespace(),
             execution.getFlowId(),
@@ -162,4 +163,6 @@ public interface FlowRepositoryInterface {
     FlowWithSource update(GenericFlow flow, FlowInterface previous) throws ConstraintViolationException;
 
     FlowWithSource delete(FlowInterface flow);
+
+    Boolean existAnyNoAcl(String tenantId);
 }

core/src/main/java/io/kestra/core/repositories/LocalFlowRepositoryLoader.java

@@ -83,7 +83,9 @@ public class LocalFlowRepositoryLoader {
     }
 
     public void load(String tenantId, File basePath) throws IOException {
-        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants().stream()
+        Map<String, FlowInterface> flowByUidInRepository = flowRepository.findAllForAllTenants()
+            .stream()
+            .filter(flow -> tenantId.equals(flow.getTenantId()))
             .collect(Collectors.toMap(FlowId::uidWithoutRevision, Function.identity()));
 
         try (Stream<Path> pathStream = Files.walk(basePath.toPath())) {

core/src/main/java/io/kestra/core/runners/ConcurrencyLimit.java

@@ -1,31 +0,0 @@
-package io.kestra.core.runners;
-
-import io.kestra.core.models.HasUID;
-import io.kestra.core.utils.IdUtils;
-import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Builder;
-import lombok.Value;
-import lombok.With;
-
-@Value
-@AllArgsConstructor
-@Builder
-public class ConcurrencyLimit implements HasUID {
-    @NotNull
-    String tenantId;
-
-    @NotNull
-    String namespace;
-
-    @NotNull
-    String flowId;
-
-    @With
-    Integer running;
-
-    @Override
-    public String uid() {
-        return IdUtils.fromPartsAndSeparator('|', this.tenantId, this.namespace, this.flowId);
-    }
-}

core/src/main/java/io/kestra/core/runners/ExecutableUtils.java

@@ -5,10 +5,7 @@ import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.InternalException;
 import io.kestra.core.models.Label;
 import io.kestra.core.models.executions.*;
-import io.kestra.core.models.flows.Flow;
-import io.kestra.core.models.flows.FlowInterface;
-import io.kestra.core.models.flows.FlowWithException;
-import io.kestra.core.models.flows.State;
+import io.kestra.core.models.flows.*;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.tasks.ExecutableTask;
 import io.kestra.core.models.tasks.Task;
@@ -29,6 +26,7 @@ import org.apache.commons.lang3.stream.Streams;
 import java.time.Instant;
 import java.time.ZonedDateTime;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static io.kestra.core.trace.Tracer.throwCallable;
 import static io.kestra.core.utils.Rethrow.throwConsumer;
@@ -153,14 +151,22 @@ public final class ExecutableUtils {
                     currentFlow.getNamespace(),
                     currentFlow.getId()
                 )
-                .orElseThrow(() -> new IllegalStateException("Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'"));
+                .orElseThrow(() -> {
+                    String msg = "Unable to find flow '" + subflowNamespace + "'.'" + subflowId + "' with revision '" + subflowRevision.orElse(0) + "'";
+                    runContext.logger().error(msg);
+                    return new IllegalStateException(msg);
+                });
 
             if (flow.isDisabled()) {
-                throw new IllegalStateException("Cannot execute a flow which is disabled");
+                String msg = "Cannot execute a flow which is disabled";
+                runContext.logger().error(msg);
+                throw new IllegalStateException(msg);
             }
 
             if (flow instanceof FlowWithException fwe) {
-                throw new IllegalStateException("Cannot execute an invalid flow: " + fwe.getException());
+                String msg = "Cannot execute an invalid flow: " + fwe.getException();
+                runContext.logger().error(msg);
+                throw new IllegalStateException(msg);
             }
 
             List<Label> newLabels = inheritLabels ? new ArrayList<>(filterLabels(currentExecution.getLabels(), flow)) : new ArrayList<>(systemLabels(currentExecution));
@@ -201,7 +207,20 @@ public final class ExecutableUtils {
                     .build()
                 )
                 .withScheduleDate(scheduleOnDate);
-
+                if(execution.getInputs().size()<inputs.size()) {
+                    Map<String,Object>resolvedInputs=execution.getInputs();
+                    for (var inputKey : inputs.keySet()) {
+                        if (!resolvedInputs.containsKey(inputKey)) {
+                            runContext.logger().warn(
+                                "Input {} was provided by parent execution {} for subflow {}.{} but isn't declared at the subflow inputs",
+                                inputKey,
+                                currentExecution.getId(),
+                                currentTask.subflowId().namespace(),
+                                currentTask.subflowId().flowId()
+                            );
+                        }
+                    }
+                }
             // inject the traceparent into the new execution
             propagator.ifPresent(pg -> pg.inject(Context.current(), execution, ExecutionTextMapSetter.INSTANCE));
 

core/src/main/java/io/kestra/core/runners/FlowInputOutput.java

@@ -1,6 +1,7 @@
 package io.kestra.core.runners;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.annotations.VisibleForTesting;
 import io.kestra.core.encryption.EncryptionService;
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.exceptions.KestraRuntimeException;
@@ -48,15 +49,7 @@ import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalTime;
-import java.util.AbstractMap;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
@@ -72,28 +65,31 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
 public class FlowInputOutput {
     private static final Pattern URI_PATTERN = Pattern.compile("^[a-z]+:\\/\\/(?:www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{1,256}\\.[a-zA-Z0-9()]{1,6}\\b(?:[-a-zA-Z0-9()@:%_\\+.~#?&\\/=]*)$");
     private static final ObjectMapper YAML_MAPPER = JacksonMapper.ofYaml();
-    
+
     private final StorageInterface storageInterface;
     private final Optional<String> secretKey;
     private final RunContextFactory runContextFactory;
-    
+    private final VariableRenderer variableRenderer;
+
     @Inject
     public FlowInputOutput(
         StorageInterface storageInterface,
         RunContextFactory runContextFactory,
+        VariableRenderer variableRenderer,
         @Nullable @Value("${kestra.encryption.secret-key}") String secretKey
     ) {
         this.storageInterface = storageInterface;
         this.runContextFactory = runContextFactory;
         this.secretKey = Optional.ofNullable(secretKey);
+        this.variableRenderer = variableRenderer;
     }
-    
+
     /**
      * Validate all the inputs of a given execution of a flow.
      *
-     * @param inputs    The Flow's inputs.
-     * @param execution The Execution.
-     * @param data      The Execution's inputs data.
+     * @param inputs                  The Flow's inputs.
+     * @param execution               The Execution.
+     * @param data                    The Execution's inputs data.
      * @return The list of {@link InputAndValue}.
      */
     public Mono<List<InputAndValue>> validateExecutionInputs(final List<Input<?>> inputs,
@@ -101,11 +97,10 @@ public class FlowInputOutput {
                                                              final Execution execution,
                                                              final Publisher<CompletedPart> data) {
         if (ListUtils.isEmpty(inputs)) return Mono.just(Collections.emptyList());
-        
-        return readData(inputs, execution, data, false)
-            .map(inputData -> resolveInputs(inputs, flow, execution, inputData, false));
+
+        return readData(inputs, execution, data, false).map(inputData -> resolveInputs(inputs, flow, execution, inputData));
     }
-    
+
     /**
      * Reads all the inputs of a given execution of a flow.
      *
@@ -119,7 +114,7 @@ public class FlowInputOutput {
                                                          final Publisher<CompletedPart> data) {
         return this.readExecutionInputs(flow.getInputs(), flow, execution, data);
     }
-    
+
     /**
      * Reads all the inputs of a given execution of a flow.
      *
@@ -134,7 +129,7 @@ public class FlowInputOutput {
                                                          final Publisher<CompletedPart> data) {
         return readData(inputs, execution, data, true).map(inputData -> this.readExecutionInputs(inputs, flow, execution, inputData));
     }
-    
+
     private Mono<Map<String, Object>> readData(List<Input<?>> inputs, Execution execution, Publisher<CompletedPart> data, boolean uploadFiles) {
         return Flux.from(data)
             .publishOn(Schedulers.boundedElastic())
@@ -217,7 +212,7 @@ public class FlowInputOutput {
         final Execution execution,
         final Map<String, ?> data
     ) {
-        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data, true)
+        Map<String, Object> resolved = this.resolveInputs(inputs, flow, execution, data)
             .stream()
             .filter(InputAndValue::enabled)
             .map(it -> {
@@ -228,9 +223,22 @@ public class FlowInputOutput {
                 return new AbstractMap.SimpleEntry<>(it.input().getId(), it.value());
             })
             .collect(HashMap::new, (m,v)-> m.put(v.getKey(), v.getValue()), HashMap::putAll);
+        if (resolved.size() < data.size()) {
+            RunContext runContext = runContextFactory.of(flow, execution);
+            for (var inputKey : data.keySet()) {
+                if (!resolved.containsKey(inputKey)) {
+                    runContext.logger().warn(
+                        "Input {} was provided for workflow {}.{} but isn't declared in the workflow inputs",
+                        inputKey,
+                        flow.getNamespace(),
+                        flow.getId()
+                    );
+                }
+            }
+        }
         return MapUtils.flattenToNestedMap(resolved);
     }
-    
+
     /**
      * Utility method for retrieving types inputs.
      *
@@ -239,21 +247,12 @@ public class FlowInputOutput {
      * @param data      The Execution's inputs data.
      * @return The Map of typed inputs.
      */
+    @VisibleForTesting
     public List<InputAndValue> resolveInputs(
         final List<Input<?>> inputs,
         final FlowInterface flow,
         final Execution execution,
         final Map<String, ?> data
-    ) {
-        return resolveInputs(inputs, flow, execution, data, true);
-    }
-    
-    public List<InputAndValue> resolveInputs(
-        final List<Input<?>> inputs,
-        final FlowInterface flow,
-        final Execution execution,
-        final Map<String, ?> data,
-        final boolean decryptSecrets
     ) {
         if (inputs == null) {
             return Collections.emptyList();
@@ -263,7 +262,7 @@ public class FlowInputOutput {
             .map(input -> ResolvableInput.of(input,data.get(input.getId())))
             .collect(Collectors.toMap(it -> it.get().input().getId(), Function.identity(), (o1, o2) -> o1, LinkedHashMap::new)));
 
-        resolvableInputMap.values().forEach(input -> resolveInputValue(input, flow, execution, resolvableInputMap, decryptSecrets));
+        resolvableInputMap.values().forEach(input -> resolveInputValue(input, flow, execution, resolvableInputMap));
 
         return resolvableInputMap.values().stream().map(ResolvableInput::get).toList();
     }
@@ -273,8 +272,7 @@ public class FlowInputOutput {
         final @NotNull ResolvableInput resolvable,
         final FlowInterface flow,
         final @NotNull Execution execution,
-        final @NotNull Map<String, ResolvableInput> inputs,
-        final boolean decryptSecrets) {
+        final @NotNull Map<String, ResolvableInput> inputs) {
 
         // return immediately if the input is already resolved
         if (resolvable.isResolved()) return resolvable.get();
@@ -283,8 +281,8 @@ public class FlowInputOutput {
 
         try {
             //  resolve all input dependencies and check whether input is enabled
-            final Map<String, InputAndValue> dependencies = resolveAllDependentInputs(input, flow, execution, inputs, decryptSecrets);
-            final RunContext runContext = buildRunContextForExecutionAndInputs(flow, execution, dependencies, decryptSecrets);
+            final Map<String, InputAndValue> dependencies = resolveAllDependentInputs(input, flow, execution, inputs);
+            final RunContext runContext = buildRunContextForExecutionAndInputs(flow, execution, dependencies);
 
             boolean isInputEnabled = dependencies.isEmpty() || dependencies.values().stream().allMatch(InputAndValue::enabled);
 
@@ -319,15 +317,16 @@ public class FlowInputOutput {
                 }
             });
             resolvable.setInput(input);
-            
+
+
             Object value = resolvable.get().value();
-            
+
             // resolve default if needed
             if (value == null && input.getDefaults() != null) {
                 value = resolveDefaultValue(input, runContext);
                 resolvable.isDefault(true);
             }
-            
+
             // validate and parse input value
             if (value == null) {
                 if (input.getRequired()) {
@@ -356,7 +355,7 @@ public class FlowInputOutput {
 
         return resolvable.get();
     }
-    
+
     public static Object resolveDefaultValue(Input<?> input, PropertyContext renderer) throws IllegalVariableEvaluationException {
         return switch (input.getType()) {
             case STRING, ENUM, SELECT, SECRET, EMAIL -> resolveDefaultPropertyAs(input, renderer, String.class);
@@ -373,7 +372,7 @@ public class FlowInputOutput {
             case MULTISELECT -> resolveDefaultPropertyAsList(input, renderer, String.class);
         };
     }
-    
+
     @SuppressWarnings("unchecked")
     private static <T> Object resolveDefaultPropertyAs(Input<?> input, PropertyContext renderer, Class<T> clazz) throws IllegalVariableEvaluationException {
         return Property.as((Property<T>) input.getDefaults(), renderer, clazz);
@@ -383,7 +382,7 @@ public class FlowInputOutput {
         return Property.asList((Property<List<T>>) input.getDefaults(), renderer, clazz);
     }
 
-    private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies, final boolean decryptSecrets) {
+    private RunContext buildRunContextForExecutionAndInputs(final FlowInterface flow, final Execution execution, Map<String, InputAndValue> dependencies) {
         Map<String, Object> flattenInputs = MapUtils.flattenToNestedMap(dependencies.entrySet()
             .stream()
             .collect(HashMap::new, (m, v) -> m.put(v.getKey(), v.getValue().value()), HashMap::putAll)
@@ -397,10 +396,10 @@ public class FlowInputOutput {
                 flattenInputs.put(input.getId(), null);
             }
         }
-        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs), decryptSecrets);
+        return runContextFactory.of(flow, execution, vars -> vars.withInputs(flattenInputs));
     }
 
-    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs, final boolean decryptSecrets) {
+    private Map<String, InputAndValue> resolveAllDependentInputs(final Input<?> input, final FlowInterface flow, final Execution execution, final Map<String, ResolvableInput> inputs) {
         return Optional.ofNullable(input.getDependsOn())
             .map(DependsOn::inputs)
             .stream()
@@ -408,7 +407,7 @@ public class FlowInputOutput {
             .filter(id -> !id.equals(input.getId()))
             .map(inputs::get)
             .filter(Objects::nonNull) // input may declare unknown or non-necessary dependencies. Let's ignore.
-            .map(it -> resolveInputValue(it, flow, execution, inputs, decryptSecrets))
+            .map(it -> resolveInputValue(it, flow, execution, inputs))
             .collect(Collectors.toMap(it -> it.input().getId(), Function.identity()));
     }
 
@@ -459,7 +458,7 @@ public class FlowInputOutput {
         if (data.getType() == null) {
             return Optional.of(new AbstractMap.SimpleEntry<>(data.getId(), current));
         }
-        
+
         final Type elementType = data instanceof ItemTypeInterface itemTypeInterface ? itemTypeInterface.getItemType() : null;
 
         return Optional.of(new AbstractMap.SimpleEntry<>(
@@ -536,17 +535,17 @@ public class FlowInputOutput {
             throw new Exception("Expected `" + type + "` but received `" + current + "` with errors:\n```\n" + e.getMessage() + "\n```");
         }
     }
-    
+
     public static Map<String, Object> renderFlowOutputs(List<Output> outputs, RunContext runContext) throws IllegalVariableEvaluationException {
         if (outputs == null) return Map.of();
-        
+
         // render required outputs
         Map<String, Object> outputsById = outputs
             .stream()
             .filter(output -> output.getRequired() == null || output.getRequired())
             .collect(HashMap::new, (map, entry) -> map.put(entry.getId(), entry.getValue()), Map::putAll);
         outputsById = runContext.render(outputsById);
-        
+
         // render optional outputs one by one to catch, log, and skip any error.
         for (io.kestra.core.models.flows.Output output : outputs) {
             if (Boolean.FALSE.equals(output.getRequired())) {
@@ -589,9 +588,9 @@ public class FlowInputOutput {
         }
 
         public void isDefault(boolean isDefault) {
-            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());  
+            this.input = new InputAndValue(this.input.input(), this.input.value(), this.input.enabled(), isDefault, this.input.exception());
         }
-        
+
         public void setInput(final Input<?> input) {
             this.input = new InputAndValue(input, this.input.value(), this.input.enabled(), this.input.isDefault(), this.input.exception());
         }

core/src/main/java/io/kestra/core/runners/RunContextFactory.java

@@ -41,9 +41,6 @@ public class RunContextFactory {
 
     @Inject
     protected VariableRenderer variableRenderer;
-    
-    @Inject
-    protected SecureVariableRendererFactory secureVariableRendererFactory;
 
     @Inject
     protected StorageInterface storageInterface;
@@ -85,33 +82,22 @@ public class RunContextFactory {
     public RunContext of(FlowInterface flow, Execution execution) {
         return of(flow, execution, Function.identity());
     }
-    
-    public RunContext of(FlowInterface flow, Execution execution, boolean decryptVariable) {
-        return of(flow, execution, Function.identity(), decryptVariable);
-    }
 
     public RunContext of(FlowInterface flow, Execution execution, Function<RunVariables.Builder, RunVariables.Builder> runVariableModifier) {
-        return of(flow, execution, runVariableModifier, true);
-    }
-    
-    public RunContext of(FlowInterface flow, Execution execution, Function<RunVariables.Builder, RunVariables.Builder> runVariableModifier, boolean decryptVariables) {
         RunContextLogger runContextLogger = runContextLoggerFactory.create(execution);
-        
-        VariableRenderer variableRenderer = decryptVariables ? this.variableRenderer : secureVariableRendererFactory.createOrGet();
-        
+
         return newBuilder()
             // Logger
             .withLogger(runContextLogger)
             // Execution
             .withPluginConfiguration(Map.of())
             .withStorage(new InternalStorage(runContextLogger.logger(), StorageContext.forExecution(execution), storageInterface, flowService))
-            .withVariableRenderer(variableRenderer)
             .withVariables(runVariableModifier.apply(
-                    newRunVariablesBuilder()
-                        .withFlow(flow)
-                        .withExecution(execution)
-                        .withDecryptVariables(decryptVariables)
-                        .withSecretInputs(secretInputsFromFlow(flow))
+                newRunVariablesBuilder()
+                    .withFlow(flow)
+                    .withExecution(execution)
+                    .withDecryptVariables(true)
+                    .withSecretInputs(secretInputsFromFlow(flow))
                 )
                 .build(runContextLogger, PropertyContext.create(variableRenderer)))
             .withSecretInputs(secretInputsFromFlow(flow))
@@ -123,7 +109,7 @@ public class RunContextFactory {
     }
 
     public RunContext of(FlowInterface flow, Task task, Execution execution, TaskRun taskRun, boolean decryptVariables) {
-        return this.of(flow, task, execution, taskRun, decryptVariables, this.variableRenderer);
+        return this.of(flow, task, execution, taskRun, decryptVariables, variableRenderer);
     }
 
     public RunContext of(FlowInterface flow, Task task, Execution execution, TaskRun taskRun, boolean decryptVariables, VariableRenderer variableRenderer) {
@@ -161,7 +147,7 @@ public class RunContextFactory {
                 .withFlow(flow)
                 .withTrigger(trigger)
                 .withSecretInputs(secretInputsFromFlow(flow))
-                .build(runContextLogger, PropertyContext.create(this.variableRenderer))
+                .build(runContextLogger, PropertyContext.create(variableRenderer))
             )
             .withSecretInputs(secretInputsFromFlow(flow))
             .withTrigger(trigger)
@@ -240,7 +226,7 @@ public class RunContextFactory {
             // inject mandatory services and config
             .withApplicationContext(applicationContext) // TODO - ideally application should not be injected here
             .withMeterRegistry(metricRegistry)
-            .withVariableRenderer(this.variableRenderer)
+            .withVariableRenderer(variableRenderer)
             .withStorageInterface(storageInterface)
             .withSecretKey(secretKey)
             .withWorkingDir(workingDirFactory.createWorkingDirectory())

core/src/main/java/io/kestra/core/runners/SecureVariableRendererFactory.java

@@ -1,39 +0,0 @@
-package io.kestra.core.runners;
-
-import io.kestra.core.runners.pebble.PebbleEngineFactory;
-import io.kestra.core.runners.pebble.functions.SecretFunction;
-import io.micronaut.context.ApplicationContext;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import java.util.List;
-
-@Singleton
-public class SecureVariableRendererFactory {
-    
-    private final PebbleEngineFactory pebbleEngineFactory;
-    private final ApplicationContext applicationContext;
-    
-    private VariableRenderer secureVariableRenderer;
-    
-    @Inject
-    public SecureVariableRendererFactory(ApplicationContext applicationContext, PebbleEngineFactory pebbleEngineFactory) {
-        this.pebbleEngineFactory = pebbleEngineFactory;
-        this.applicationContext = applicationContext;
-    }
-    
-    /**
-     * Creates or returns the existing secured {@link VariableRenderer} instance.
-     *
-     * @return the secured {@link VariableRenderer} instance
-     */
-    public synchronized VariableRenderer createOrGet() {
-        if (this.secureVariableRenderer == null) {
-            // Explicitly create a new instance through the application context to ensure
-            // eventual custom VariableRenderer implementation is used
-            secureVariableRenderer = applicationContext.createBean(VariableRenderer.class);
-            secureVariableRenderer.setPebbleEngine(pebbleEngineFactory.createWithMaskedFunctions(secureVariableRenderer, List.of(SecretFunction.NAME)));
-        }
-        return secureVariableRenderer;
-    }
-}
-

core/src/main/java/io/kestra/core/runners/VariableRenderer.java

@@ -2,44 +2,121 @@ package io.kestra.core.runners;
 
 import io.kestra.core.exceptions.IllegalVariableEvaluationException;
 import io.kestra.core.runners.pebble.*;
+import io.kestra.core.runners.pebble.functions.RenderingFunctionInterface;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.annotation.ConfigurationProperties;
 import io.micronaut.core.annotation.Nullable;
 import io.pebbletemplates.pebble.PebbleEngine;
 import io.pebbletemplates.pebble.error.AttributeNotFoundException;
 import io.pebbletemplates.pebble.error.PebbleException;
+import io.pebbletemplates.pebble.extension.Extension;
+import io.pebbletemplates.pebble.extension.Function;
 import io.pebbletemplates.pebble.template.PebbleTemplate;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import lombok.Getter;
 
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Proxy;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 @Singleton
 public class VariableRenderer {
     private static final Pattern RAW_PATTERN = Pattern.compile("(\\{%-*\\s*raw\\s*-*%}(.*?)\\{%-*\\s*endraw\\s*-*%})");
     public static final int MAX_RENDERING_AMOUNT = 100;
 
-    private PebbleEngine pebbleEngine;
+    private final PebbleEngine pebbleEngine;
     private final VariableConfiguration variableConfiguration;
 
     @Inject
     public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration) {
-        this(applicationContext.getBean(PebbleEngineFactory.class), variableConfiguration);
+        this(applicationContext, variableConfiguration, Collections.emptyList());
     }
-    
-    public VariableRenderer(PebbleEngineFactory pebbleEngineFactory, @Nullable VariableConfiguration variableConfiguration) {
+
+    public VariableRenderer(ApplicationContext applicationContext, @Nullable VariableConfiguration variableConfiguration, List<String> functionsToMask) {
         this.variableConfiguration = variableConfiguration != null ? variableConfiguration : new VariableConfiguration();
-        this.pebbleEngine = pebbleEngineFactory.create();
+
+        PebbleEngine.Builder pebbleBuilder = new PebbleEngine.Builder()
+            .registerExtensionCustomizer(ExtensionCustomizer::new)
+            .strictVariables(true)
+            .cacheActive(this.variableConfiguration.getCacheEnabled())
+            .newLineTrimming(false)
+            .autoEscaping(false);
+
+        List<Extension> extensions = applicationContext.getBeansOfType(Extension.class).stream()
+            .map(e -> functionsToMask.stream().anyMatch(excludedFunction -> e.getFunctions().containsKey(excludedFunction))
+                ? extensionWithMaskedFunctions(e, functionsToMask)
+                : e)
+            .toList();
+
+        extensions.forEach(pebbleBuilder::extension);
+
+        if (this.variableConfiguration.getCacheEnabled()) {
+            pebbleBuilder.templateCache(new PebbleLruCache(this.variableConfiguration.getCacheSize()));
+        }
+
+        this.pebbleEngine = pebbleBuilder.build();
     }
-    
-    public void setPebbleEngine(final PebbleEngine pebbleEngine) {
-        this.pebbleEngine = pebbleEngine;
+
+    private Extension extensionWithMaskedFunctions(Extension initialExtension, List<String> maskedFunctions) {
+        return (Extension) Proxy.newProxyInstance(
+            initialExtension.getClass().getClassLoader(),
+            new Class[]{Extension.class},
+            (proxy, method, methodArgs) -> {
+                if (method.getName().equals("getFunctions")) {
+                    return initialExtension.getFunctions().entrySet().stream()
+                        .map(entry -> {
+                            if (maskedFunctions.contains(entry.getKey())) {
+                                return Map.entry(entry.getKey(), this.maskedFunctionProxy(entry.getValue()));
+                            } else if (RenderingFunctionInterface.class.isAssignableFrom(entry.getValue().getClass())) {
+                                return Map.entry(entry.getKey(), this.variableRendererProxy(entry.getValue()));
+                            }
+
+                            return entry;
+                        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+                }
+
+                return method.invoke(initialExtension, methodArgs);
+            }
+        );
     }
-    
+
+    private Function variableRendererProxy(Function initialFunction) {
+        return (Function) Proxy.newProxyInstance(
+            initialFunction.getClass().getClassLoader(),
+            new Class[]{Function.class, RenderingFunctionInterface.class},
+            (functionProxy, functionMethod, functionArgs) -> {
+                if (functionMethod.getName().equals("variableRenderer")) {
+                    return this;
+                }
+                return functionMethod.invoke(initialFunction, functionArgs);
+            }
+        );
+    }
+
+    private Function maskedFunctionProxy(Function initialFunction) {
+        return (Function) Proxy.newProxyInstance(
+            initialFunction.getClass().getClassLoader(),
+            new Class[]{Function.class},
+            (functionProxy, functionMethod, functionArgs) -> {
+                Object result;
+                try {
+                    result = functionMethod.invoke(initialFunction, functionArgs);
+                } catch (InvocationTargetException e) {
+                    throw e.getCause();
+                }
+                if (functionMethod.getName().equals("execute")) {
+                    return "******";
+                }
+                return result;
+            }
+        );
+    }
+
     public static IllegalVariableEvaluationException properPebbleException(PebbleException initialExtension) {
         if (initialExtension instanceof AttributeNotFoundException current) {
             return new IllegalVariableEvaluationException(

core/src/main/java/io/kestra/core/runners/pebble/Extension.java

@@ -168,6 +168,7 @@ public class Extension extends AbstractExtension {
         functions.put("randomPort", new RandomPortFunction());
         functions.put("fileExists", fileExistsFunction);
         functions.put("isFileEmpty", isFileEmptyFunction);
+        functions.put("nanoId", new NanoIDFunction());
         functions.put("tasksWithState", new TasksWithStateFunction());
         functions.put(HttpFunction.NAME, httpFunction);
         return functions;

core/src/main/java/io/kestra/core/runners/pebble/PebbleEngineFactory.java

@@ -1,118 +0,0 @@
-package io.kestra.core.runners.pebble;
-
-import io.kestra.core.runners.VariableRenderer;
-import io.kestra.core.runners.pebble.functions.RenderingFunctionInterface;
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.core.annotation.Nullable;
-import io.pebbletemplates.pebble.PebbleEngine;
-import io.pebbletemplates.pebble.extension.Extension;
-import io.pebbletemplates.pebble.extension.Function;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Proxy;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Singleton
-public class PebbleEngineFactory {
-    
-    private final ApplicationContext applicationContext;
-    private final VariableRenderer.VariableConfiguration variableConfiguration;
-    
-    @Inject
-    public PebbleEngineFactory(ApplicationContext applicationContext, @Nullable VariableRenderer.VariableConfiguration variableConfiguration) {
-        this.applicationContext = applicationContext;
-        this.variableConfiguration = variableConfiguration;
-    }
-    
-    public PebbleEngine create() {
-        PebbleEngine.Builder builder = newPebbleEngineBuilder();
-        this.applicationContext.getBeansOfType(Extension.class).forEach(builder::extension);
-        return builder.build();
-    }
-    
-    public PebbleEngine createWithMaskedFunctions(VariableRenderer renderer, final List<String> functionsToMask) {
-        
-        PebbleEngine.Builder builder = newPebbleEngineBuilder();
-        
-        this.applicationContext.getBeansOfType(Extension.class).stream()
-            .map(e -> functionsToMask.stream().anyMatch(fun -> e.getFunctions().containsKey(fun))
-                ? extensionWithMaskedFunctions(renderer, e, functionsToMask)
-                : e)
-            .forEach(builder::extension);
-        
-        return builder.build();
-    }
-    
-    private PebbleEngine.Builder newPebbleEngineBuilder() {
-        PebbleEngine.Builder builder = new PebbleEngine.Builder()
-            .registerExtensionCustomizer(ExtensionCustomizer::new)
-            .strictVariables(true)
-            .cacheActive(this.variableConfiguration.getCacheEnabled())
-            .newLineTrimming(false)
-            .autoEscaping(false);
-        
-        if (this.variableConfiguration.getCacheEnabled()) {
-            builder = builder.templateCache(new PebbleLruCache(this.variableConfiguration.getCacheSize()));
-        }
-        return builder;
-    }
-    
-    private Extension extensionWithMaskedFunctions(VariableRenderer renderer, Extension initialExtension, List<String> maskedFunctions) {
-        return (Extension) Proxy.newProxyInstance(
-            initialExtension.getClass().getClassLoader(),
-            new Class[]{Extension.class},
-            (proxy, method, methodArgs) -> {
-                if (method.getName().equals("getFunctions")) {
-                    return initialExtension.getFunctions().entrySet().stream()
-                        .map(entry -> {
-                            if (maskedFunctions.contains(entry.getKey())) {
-                                return Map.entry(entry.getKey(), this.maskedFunctionProxy(entry.getValue()));
-                            } else if (RenderingFunctionInterface.class.isAssignableFrom(entry.getValue().getClass())) {
-                                return Map.entry(entry.getKey(), this.variableRendererProxy(renderer, entry.getValue()));
-                            }
-                            
-                            return entry;
-                        }).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-                }
-                
-                return method.invoke(initialExtension, methodArgs);
-            }
-        );
-    }
-    
-    private Function variableRendererProxy(VariableRenderer renderer, Function initialFunction) {
-        return (Function) Proxy.newProxyInstance(
-            initialFunction.getClass().getClassLoader(),
-            new Class[]{Function.class, RenderingFunctionInterface.class},
-            (functionProxy, functionMethod, functionArgs) -> {
-                if (functionMethod.getName().equals("variableRenderer")) {
-                    return renderer;
-                }
-                return functionMethod.invoke(initialFunction, functionArgs);
-            }
-        );
-    }
-    
-    private Function maskedFunctionProxy(Function initialFunction) {
-        return (Function) Proxy.newProxyInstance(
-            initialFunction.getClass().getClassLoader(),
-            new Class[]{Function.class},
-            (functionProxy, functionMethod, functionArgs) -> {
-                Object result;
-                try {
-                    result = functionMethod.invoke(initialFunction, functionArgs);
-                } catch (InvocationTargetException e) {
-                    throw e.getCause();
-                }
-                if (functionMethod.getName().equals("execute")) {
-                    return "******";
-                }
-                return result;
-            }
-        );
-    }
-}

core/src/main/java/io/kestra/core/runners/pebble/filters/TimestampMicroFilter.java

@@ -30,6 +30,6 @@ public class TimestampMicroFilter extends AbstractDate implements Filter {
         ZoneId zoneId = zoneId(timeZone);
         ZonedDateTime date = convert(input, zoneId, existingFormat);
 
-        return String.valueOf(TimeUnit.SECONDS.toNanos(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
+        return String.valueOf(TimeUnit.SECONDS.toMicros(date.toEpochSecond()) + TimeUnit.NANOSECONDS.toMicros(date.getNano()));
     }
 }

core/src/main/java/io/kestra/core/runners/pebble/functions/HttpFunction.java

@@ -5,6 +5,8 @@ import io.kestra.core.http.HttpRequest;
 import io.kestra.core.http.HttpResponse;
 import io.kestra.core.http.client.HttpClient;
 import io.kestra.core.http.client.HttpClientException;
+import io.kestra.core.http.client.HttpClientRequestException;
+import io.kestra.core.http.client.HttpClientResponseException;
 import io.kestra.core.http.client.configurations.HttpConfiguration;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.RunContextFactory;
@@ -101,8 +103,15 @@ public class HttpFunction<T> implements Function {
         try (HttpClient httpClient = new HttpClient(runContext, httpConfiguration)) {
             HttpResponse<Object> response = httpClient.request(httpRequest, Object.class);
             return response.getBody();
-        } catch (HttpClientException | IllegalVariableEvaluationException | IOException e) {
-            throw new PebbleException(e, "Unable to execute HTTP request", lineNumber, self.getName());
+        } catch (HttpClientResponseException e) {
+            if (e.getResponse() != null) {
+                String msg = "Failed to execute HTTP Request, server respond with status " + e.getResponse().getStatus().getCode() + " : " + e.getResponse().getStatus().getReason();
+                throw new PebbleException(e, msg , lineNumber, self.getName());
+            } else {
+                throw new PebbleException( e, "Failed to execute HTTP request ", lineNumber, self.getName());
+            }
+        } catch(HttpClientException | IllegalVariableEvaluationException | IOException e ) {
+            throw new PebbleException( e, "Failed to execute HTTP request ", lineNumber, self.getName());
         }
     }
 

core/src/main/java/io/kestra/core/runners/pebble/functions/NanoIDFunction.java

@@ -0,0 +1,66 @@
+package io.kestra.core.runners.pebble.functions;
+
+import io.pebbletemplates.pebble.error.PebbleException;
+import io.pebbletemplates.pebble.extension.Function;
+import io.pebbletemplates.pebble.template.EvaluationContext;
+import io.pebbletemplates.pebble.template.PebbleTemplate;
+
+import java.security.SecureRandom;
+import java.util.List;
+import java.util.Map;
+
+public class NanoIDFunction implements Function {
+
+    private static final int DEFAULT_LENGTH = 21;
+    private static final char[] DEFAULT_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".toCharArray();
+    private static final SecureRandom secureRandom = new SecureRandom();
+
+    private static final String LENGTH = "length";
+    private static final String ALPHABET = "alphabet";
+
+    private static final int MAX_LENGTH = 1000;
+
+    @Override
+    public Object execute(
+        Map<String, Object> args, PebbleTemplate self, EvaluationContext context, int lineNumber) {
+        int length = DEFAULT_LENGTH;
+        if (args.containsKey(LENGTH) && (args.get(LENGTH) instanceof Long)) {
+            length = parseLength(args, self, lineNumber);
+        }
+        char[] alphabet = DEFAULT_ALPHABET;
+        if (args.containsKey(ALPHABET) && (args.get(ALPHABET) instanceof String)) {
+            alphabet = ((String) args.get(ALPHABET)).toCharArray();
+        }
+        return createNanoID(length, alphabet);
+    }
+
+    private static int parseLength(Map<String, Object> args, PebbleTemplate self, int lineNumber) {
+        var value = (Long) args.get(LENGTH);
+        if(value > MAX_LENGTH) {
+            throw new PebbleException(
+                null,
+                "The 'nanoId()' function field 'length' must be lower than: " + MAX_LENGTH,
+                lineNumber,
+                self.getName());
+        }
+        return Math.toIntExact(value);
+    }
+
+    @Override
+    public List<String> getArgumentNames() {
+        return List.of(LENGTH,ALPHABET);
+    }
+
+    String createNanoID(int length, char[] alphabet){
+        final char[] data = new char[length];
+        final byte[] bytes = new byte[length];
+        final int mask = alphabet.length-1;
+        secureRandom.nextBytes(bytes);
+        for (int i = 0; i < length; ++i) {
+            data[i] = alphabet[bytes[i] & mask];
+        }
+        return String.valueOf(data);
+    }
+
+
+}

core/src/main/java/io/kestra/core/serializers/FileSerde.java

@@ -180,23 +180,13 @@ public final class FileSerde {
     }
 
     private static <T> MappingIterator<T> createMappingIterator(ObjectMapper objectMapper, Reader reader, TypeReference<T> type) throws IOException {
-        // See https://github.com/FasterXML/jackson-dataformats-binary/issues/493
-        // There is a limitation with the MappingIterator that cannot differentiate between an array of things (of whatever shape)
-        // and a sequence/stream of things (of Array shape).
-        // To work around that, we need to create a JsonParser and advance to the first token.
         try (var parser = objectMapper.createParser(reader)) {
-            parser.nextToken();
             return objectMapper.readerFor(type).readValues(parser);
         }
     }
 
     private static <T> MappingIterator<T> createMappingIterator(ObjectMapper objectMapper, Reader reader, Class<T> type) throws IOException {
-        // See https://github.com/FasterXML/jackson-dataformats-binary/issues/493
-        // There is a limitation with the MappingIterator that cannot differentiate between an array of things (of whatever shape)
-        // and a sequence/stream of things (of Array shape).
-        // To work around that, we need to create a JsonParser and advance to the first token.
         try (var parser = objectMapper.createParser(reader)) {
-            parser.nextToken();
             return objectMapper.readerFor(type).readValues(parser);
         }
     }

core/src/main/java/io/kestra/core/services/ExecutionService.java

@@ -718,8 +718,8 @@ public class ExecutionService {
         } else {
             newExecution = execution.withState(killingOrAfterKillState);
         }
-        
-        // Because this method is expected to be called by the Executor we can return the Execution 
+
+        // Because this method is expected to be called by the Executor we can return the Execution
         // immediately without publishing a CrudEvent like it's done on pause/resume method.
         return newExecution;
     }

core/src/main/java/io/kestra/core/services/SkipExecutionService.java

@@ -5,11 +5,14 @@ import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.TaskRun;
 import jakarta.annotation.Nullable;
 import jakarta.inject.Singleton;
+import lombok.extern.slf4j.Slf4j;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 @Singleton
+@Slf4j
 public class SkipExecutionService {
     private volatile List<String> skipExecutions = Collections.emptyList();
     private volatile List<FlowId> skipFlows = Collections.emptyList();
@@ -22,11 +25,11 @@ public class SkipExecutionService {
     }
 
     public synchronized void setSkipFlows(List<String> skipFlows) {
-        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).toList();
+        this.skipFlows = skipFlows == null ? Collections.emptyList() : skipFlows.stream().map(FlowId::from).filter(Objects::nonNull).toList();
     }
 
     public synchronized void setSkipNamespaces(List<String> skipNamespaces) {
-        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).toList();
+        this.skipNamespaces = skipNamespaces == null ? Collections.emptyList() : skipNamespaces.stream().map(NamespaceId::from).filter(Objects::nonNull).toList();
     }
 
     public synchronized void setSkipTenants(List<String> skipTenants) {
@@ -73,19 +76,31 @@ public class SkipExecutionService {
     }
 
     record FlowId(String tenant, String namespace, String flow) {
-        static FlowId from(String flowId) {
+        static @Nullable FlowId from(String flowId) {
             String[] parts = SkipExecutionService.splitIdParts(flowId);
             if (parts.length == 3) {
                 return new FlowId(parts[0], parts[1], parts[2]);
+            } else if (parts.length == 2) {
+                return new FlowId(null, parts[0], parts[1]);
+            } else {
+                log.error("Invalid flow skip with values: '{}'", flowId);
             }
-            return new FlowId(null, parts[0], parts[1]);
+
+            return null;
         }
     };
 
     record NamespaceId(String tenant, String namespace) {
-        static NamespaceId from(String namespaceId) {
+        static @Nullable NamespaceId from(String namespaceId) {
             String[] parts = SkipExecutionService.splitIdParts(namespaceId);
-            return new NamespaceId(parts[0], parts[1]);
+
+            if (parts.length == 2) {
+                return new NamespaceId(parts[0], parts[1]);
+            } else {
+                log.error("Invalid namespace skip with values:'{}'", namespaceId);
+            }
+
+            return null;
         }
     };
 }

core/src/main/java/io/kestra/core/utils/RegexPatterns.java

@@ -1,5 +0,0 @@
-package io.kestra.core.utils;
-
-public class RegexPatterns {
-    public static final String JAVA_IDENTIFIER_REGEX = "^[A-Za-z_$][A-Za-z0-9_$]*(\\.[A-Za-z_$][A-Za-z0-9_$]*)*$";
-}

core/src/main/java/io/kestra/core/utils/Version.java

@@ -32,48 +32,84 @@ public class Version implements Comparable<Version> {
      * @param version   the version.
      * @return          a new {@link Version} instance.
      */
-    public static Version of(String version) {
+    public static Version of(final Object version) {
 
-        if (version.startsWith("v")) {
-            version = version.substring(1);
+        if (Objects.isNull(version)) {
+            throw new IllegalArgumentException("Invalid version, cannot parse null version");
+        }
+        
+        String strVersion = version.toString();
+        
+        if (strVersion.startsWith("v")) {
+            strVersion = strVersion.substring(1);
         }
 
-        int qualifier = version.indexOf("-");
+        int qualifier = strVersion.indexOf("-");
 
         final String[] versions = qualifier > 0 ?
-            version.substring(0, qualifier).split("\\.") :
-            version.split("\\.");
+            strVersion.substring(0, qualifier).split("\\.") :
+            strVersion.split("\\.");
         try {
             final int majorVersion = Integer.parseInt(versions[0]);
-            final int minorVersion = versions.length > 1 ? Integer.parseInt(versions[1]) : 0;
-            final int incrementalVersion = versions.length > 2 ? Integer.parseInt(versions[2]) : 0;
+            final Integer minorVersion = versions.length > 1 ? Integer.parseInt(versions[1]) : null;
+            final Integer incrementalVersion = versions.length > 2 ? Integer.parseInt(versions[2]) : null;
 
             return new Version(
                 majorVersion,
                 minorVersion,
                 incrementalVersion,
-                qualifier > 0 ? version.substring(qualifier + 1) : null,
-                version
+                qualifier > 0 ? strVersion.substring(qualifier + 1) : null,
+                strVersion
             );
         } catch (NumberFormatException e) {
             throw new IllegalArgumentException("Invalid version, cannot parse '" + version + "'");
         }
     }
-
+    
     /**
-     * Static helper method for returning the most recent stable version for a current {@link Version}.
+     * Resolves the most appropriate stable version from a collection, based on a given input version.
+     * <p>
+     * The matching rules are:
+     * <ul>
+     *   <li>If {@code from} specifies only a major version (e.g. {@code 1}), return the latest stable version
+     *       with the same major (e.g. {@code 1.2.3}).</li>
+     *   <li>If {@code from} specifies a major and minor version only (e.g. {@code 1.2}), return the latest
+     *       stable version with the same major and minor (e.g. {@code 1.2.3}).</li>
+     *   <li>If {@code from} specifies a full version with major, minor, and patch (e.g. {@code 1.2.2}),
+     *       then only return it if it is exactly present (and stable) in {@code versions}.
+     *       No "upgrade" is performed in this case.</li>
+     *   <li>If no suitable version is found, returns {@code null}.</li>
+     * </ul>
      *
-     * @param from     the current version.
-     * @param versions the list of version.
-     *
-     * @return the last stable version.
+     * @param from     the reference version (may specify only major, or major+minor, or major+minor+patch).
+     * @param versions the collection of candidate versions to resolve against.
+     * @return the best matching stable version, or {@code null} if none match.
      */
     public static Version getStable(final Version from, final Collection<Version> versions) {
-        List<Version> compatibleVersions = versions.stream()
-            .filter(v -> v.majorVersion() == from.majorVersion() && v.minorVersion() == from.minorVersion())
-            .toList();
-        if (compatibleVersions.isEmpty()) return null;
-        return Version.getLatest(compatibleVersions);
+        // Case 1: "from" is only a major (e.g. 1)
+        if (from.hasOnlyMajor()) {
+            List<Version> sameMajor = versions.stream()
+                .filter(v -> v.majorVersion() == from.majorVersion())
+                .toList();
+            return sameMajor.isEmpty() ? null : Version.getLatest(sameMajor);
+        }
+        
+        // Case 2: "from" is major+minor only (e.g. 1.2)
+        if (from.hasMajorAndMinorOnly()) {
+            List<Version> sameMinor = versions.stream()
+                .filter(v -> v.majorVersion() == from.majorVersion()
+                    && v.minorVersion() == from.minorVersion())
+                .toList();
+            return sameMinor.isEmpty() ? null : Version.getLatest(sameMinor);
+        }
+        
+        // Case 3: "from" is full version (major+minor+patch)
+        if (versions.contains(from)) {
+            return from;
+        }
+        
+        // No match
+        return null;
     }
 
     /**
@@ -123,8 +159,8 @@ public class Version implements Comparable<Version> {
     }
 
     private final int majorVersion;
-    private final int minorVersion;
-    private final int incrementalVersion;
+    private final Integer minorVersion;
+    private final Integer patchVersion;
     private final Qualifier qualifier;
 
     private final String originalVersion;
@@ -134,14 +170,14 @@ public class Version implements Comparable<Version> {
      *
      * @param majorVersion          the major version (must be superior or equal to 0).
      * @param minorVersion          the minor version (must be superior or equal to 0).
-     * @param incrementalVersion    the incremental version (must be superior or equal to 0).
+     * @param patchVersion    the incremental version (must be superior or equal to 0).
      * @param qualifier             the qualifier.
      */
     public Version(final int majorVersion,
                    final int minorVersion,
-                   final int incrementalVersion,
+                   final int patchVersion,
                    final String qualifier) {
-        this(majorVersion, minorVersion, incrementalVersion, qualifier, null);
+        this(majorVersion, minorVersion, patchVersion, qualifier, null);
     }
 
     /**
@@ -149,25 +185,25 @@ public class Version implements Comparable<Version> {
      *
      * @param majorVersion          the major version (must be superior or equal to 0).
      * @param minorVersion          the minor version (must be superior or equal to 0).
-     * @param incrementalVersion    the incremental version (must be superior or equal to 0).
+     * @param patchVersion    the incremental version (must be superior or equal to 0).
      * @param qualifier             the qualifier.
      * @param originalVersion       the original string version.
      */
-    private Version(final int majorVersion,
-                    final int minorVersion,
-                    final int incrementalVersion,
+    private Version(final Integer majorVersion,
+                    final Integer minorVersion,
+                    final Integer patchVersion,
                     final String qualifier,
                     final String originalVersion) {
         this.majorVersion =  requirePositive(majorVersion, "major");
         this.minorVersion = requirePositive(minorVersion, "minor");
-        this.incrementalVersion = requirePositive(incrementalVersion, "incremental");
+        this.patchVersion = requirePositive(patchVersion, "incremental");
         this.qualifier = qualifier != null ? new Qualifier(qualifier) : null;
         this.originalVersion = originalVersion;
     }
 
 
-    private static int requirePositive(int version, final String message) {
-        if (version < 0) {
+    private static Integer requirePositive(Integer version, final String message) {
+        if (version != null && version < 0) {
             throw new IllegalArgumentException(String.format("The '%s' version must super or equal to 0", message));
         }
         return version;
@@ -178,11 +214,11 @@ public class Version implements Comparable<Version> {
     }
 
     public int minorVersion() {
-        return minorVersion;
+        return minorVersion != null ? minorVersion : 0;
     }
 
-    public int incrementalVersion() {
-        return incrementalVersion;
+    public int patchVersion() {
+        return patchVersion != null ? patchVersion : 0;
     }
 
     public Qualifier qualifier() {
@@ -197,9 +233,9 @@ public class Version implements Comparable<Version> {
         if (this == o) return true;
         if (!(o instanceof Version)) return false;
         Version version = (Version) o;
-        return majorVersion == version.majorVersion &&
-            minorVersion == version.minorVersion &&
-            incrementalVersion == version.incrementalVersion &&
+        return Objects.equals(majorVersion,version.majorVersion) &&
+            Objects.equals(minorVersion, version.minorVersion) &&
+            Objects.equals(patchVersion,version.patchVersion) &&
             Objects.equals(qualifier, version.qualifier);
     }
 
@@ -208,7 +244,7 @@ public class Version implements Comparable<Version> {
      */
     @Override
     public int hashCode() {
-        return Objects.hash(majorVersion, minorVersion, incrementalVersion, qualifier);
+        return Objects.hash(majorVersion, minorVersion, patchVersion, qualifier);
     }
 
     /**
@@ -218,7 +254,7 @@ public class Version implements Comparable<Version> {
     public String toString() {
         if (originalVersion != null) return originalVersion;
 
-        String version =  majorVersion + "." + minorVersion + "." + incrementalVersion;
+        String version =  majorVersion + "." + minorVersion + "." + patchVersion;
         return (qualifier != null) ? version +"-" + qualifier : version;
     }
 
@@ -238,7 +274,7 @@ public class Version implements Comparable<Version> {
             return compareMinor;
         }
 
-        int compareIncremental = Integer.compare(that.incrementalVersion, this.incrementalVersion);
+        int compareIncremental = Integer.compare(that.patchVersion, this.patchVersion);
         if (compareIncremental != 0) {
             return compareIncremental;
         }
@@ -253,6 +289,21 @@ public class Version implements Comparable<Version> {
 
         return this.qualifier.compareTo(that.qualifier);
     }
+    
+    
+    /**
+     * @return true if only major is specified (e.g. "1")
+     */
+    private boolean hasOnlyMajor() {
+        return minorVersion == null && patchVersion == null;
+    }
+    
+    /**
+     * @return true if major+minor are specified, but no patch (e.g. "1.2")
+     */
+    private boolean hasMajorAndMinorOnly() {
+        return minorVersion != null && patchVersion == null;
+    }
 
     /**
      * Checks whether this version is before the given one.

core/src/main/java/io/kestra/core/utils/VersionProvider.java

@@ -46,16 +46,19 @@ public class VersionProvider {
         this.date = loadTime(gitProperties);
         this.version = loadVersion(buildProperties, gitProperties);
 
-        // check the version in the settings and update if needed, we did't use it would allow us to detect incompatible update later if needed
-        if (settingRepository.isPresent()) {
-            Optional<Setting> versionSetting = settingRepository.get().findByKey(Setting.INSTANCE_VERSION);
-            if (versionSetting.isEmpty() || !versionSetting.get().getValue().equals(this.version)) {
-                settingRepository.get().save(Setting.builder()
-                    .key(Setting.INSTANCE_VERSION)
-                    .value(this.version)
-                    .build()
-                );
-            }
+        // check the version in the settings and update if needed, we didn't use it would allow us to detect incompatible update later if needed
+        settingRepository.ifPresent(
+            settingRepositoryInterface -> persistVersion(settingRepositoryInterface, version));
+    }
+
+    private static synchronized void persistVersion(SettingRepositoryInterface settingRepositoryInterface, String version) {
+        Optional<Setting> versionSetting = settingRepositoryInterface.findByKey(Setting.INSTANCE_VERSION);
+        if (versionSetting.isEmpty() || !versionSetting.get().getValue().equals(version)) {
+            settingRepositoryInterface.save(Setting.builder()
+                .key(Setting.INSTANCE_VERSION)
+                .value(version)
+                .build()
+            );
         }
     }
 

core/src/main/java/io/kestra/plugin/core/dashboard/chart/mardown/sources/MarkdownSource.java

@@ -7,8 +7,6 @@ import jakarta.validation.constraints.NotNull;
 import jakarta.validation.constraints.Pattern;
 import lombok.Getter;
 
-import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
-
 @Getter
 @JsonTypeInfo(
     use = JsonTypeInfo.Id.NAME,
@@ -22,6 +20,6 @@ import static io.kestra.core.utils.RegexPatterns.JAVA_IDENTIFIER_REGEX;
 public class MarkdownSource {
     @NotNull
     @NotBlank
-    @Pattern(regexp = JAVA_IDENTIFIER_REGEX)
+    @Pattern(regexp = "\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*(\\.\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*)*")
     private String type;
 }

core/src/main/java/io/kestra/plugin/core/dashboard/data/Flows.java

@@ -0,0 +1,52 @@
+package io.kestra.plugin.core.dashboard.data;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import io.kestra.core.models.annotations.Example;
+import io.kestra.core.models.annotations.Plugin;
+import io.kestra.core.models.dashboards.ColumnDescriptor;
+import io.kestra.core.models.dashboards.DataFilter;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.repositories.QueryBuilderInterface;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@NoArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+@EqualsAndHashCode
+@Schema(
+    title = "Display Flow data in a dashboard chart."
+)
+@Plugin(
+    examples = {
+        @Example(
+            title = "Display a chart with a list of Flows.",
+            full = true,
+            code = { """
+            charts:
+              - id: list_flows
+                type: io.kestra.plugin.core.dashboard.chart.Table
+                data:
+                  type: io.kestra.plugin.core.dashboard.data.Flows
+                  columns:
+                    namespace:
+                      field: NAMESPACE
+                    id:
+                      field: ID
+            """
+          }
+        )
+    }
+)
+@JsonTypeName("Flows")
+public class Flows<C extends ColumnDescriptor<Flows.Fields>> extends DataFilter<Flows.Fields, C> implements IFlows {
+    @Override
+    public Class<? extends QueryBuilderInterface<Fields>> repositoryClass() {
+        return FlowRepositoryInterface.class;
+    }
+}

core/src/main/java/io/kestra/plugin/core/dashboard/data/FlowsKPI.java

@@ -0,0 +1,51 @@
+package io.kestra.plugin.core.dashboard.data;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import io.kestra.core.models.annotations.Example;
+import io.kestra.core.models.annotations.Plugin;
+import io.kestra.core.models.dashboards.ColumnDescriptor;
+import io.kestra.core.models.dashboards.DataFilterKPI;
+import io.kestra.core.repositories.FlowRepositoryInterface;
+import io.kestra.core.repositories.QueryBuilderInterface;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.experimental.SuperBuilder;
+
+@SuperBuilder(toBuilder = true)
+@Getter
+@NoArgsConstructor
+@JsonInclude(JsonInclude.Include.NON_DEFAULT)
+@EqualsAndHashCode
+@Schema(
+    title = "Display a chart with Flows KPI.",
+    description = "Change."
+)
+@Plugin(
+    examples = {
+        @Example(
+            title = "Display count of Flows.",
+            full = true,
+            code = { """
+            charts:
+              - id: kpi
+                    type: io.kestra.plugin.core.dashboard.chart.KPI
+                    data:
+                      type: io.kestra.plugin.core.dashboard.data.FlowsKPI
+                      columns:
+                        field: ID
+                        agg: COUNT
+            """
+          }
+        )
+    }
+)
+@JsonTypeName("FlowsKPI")
+public class FlowsKPI<C extends ColumnDescriptor<FlowsKPI.Fields>> extends DataFilterKPI<FlowsKPI.Fields, C> implements IFlows {
+    @Override
+    public Class<? extends QueryBuilderInterface<Fields>> repositoryClass() {
+        return FlowRepositoryInterface.class;
+    }
+}

core/src/main/java/io/kestra/plugin/core/dashboard/data/IFlows.java

@@ -0,0 +1,37 @@
+package io.kestra.plugin.core.dashboard.data;
+
+import io.kestra.core.models.QueryFilter;
+import io.kestra.core.models.dashboards.filters.AbstractFilter;
+import io.kestra.core.utils.ListUtils;
+
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+public interface IFlows extends IData<IFlows.Fields> {
+
+    default List<AbstractFilter<IFlows.Fields>> whereWithGlobalFilters(List<QueryFilter> filters, ZonedDateTime startDate, ZonedDateTime endDate, List<AbstractFilter<IFlows.Fields>> where) {
+        List<AbstractFilter<IFlows.Fields>> updatedWhere = where != null ? new ArrayList<>(where) : new ArrayList<>();
+
+        if (ListUtils.isEmpty(filters)) {
+            return updatedWhere;
+        }
+
+        List<QueryFilter> namespaceFilters = filters.stream().filter(f -> f.field().equals(QueryFilter.Field.NAMESPACE)).toList();
+        if (!namespaceFilters.isEmpty()) {
+            updatedWhere.removeIf(filter -> filter.getField().equals(IFlows.Fields.NAMESPACE));
+            namespaceFilters.forEach(f -> {
+                updatedWhere.add(f.toDashboardFilterBuilder(IFlows.Fields.NAMESPACE, f.value()));
+            });
+        }
+
+
+        return updatedWhere;
+    }
+
+    enum Fields {
+        ID,
+        NAMESPACE,
+        REVISION
+    }
+}

core/src/main/java/io/kestra/plugin/core/execution/Labels.java

@@ -127,9 +127,24 @@ public class Labels extends Task implements ExecutionUpdatableTask {
         }
 
         // check for system labels: none can be passed at runtime
-        Optional<Map.Entry<String, String>> first = labelsAsMap.entrySet().stream().filter(entry -> entry.getKey().startsWith(SYSTEM_PREFIX)).findFirst();
-        if (first.isPresent()) {
-            throw new IllegalArgumentException("System labels can only be set by Kestra itself, offending label: " + first.get().getKey() + "=" + first.get().getValue());
+        Optional<Map.Entry<String, String>> systemLabel = labelsAsMap.entrySet().stream()
+            .filter(entry -> entry.getKey().startsWith(SYSTEM_PREFIX))
+            .findFirst();
+        if (systemLabel.isPresent()) {
+            throw new IllegalArgumentException(
+                "System labels can only be set by Kestra itself, offending label: " +
+                systemLabel.get().getKey() + "=" + systemLabel.get().getValue()
+            );
+        }
+
+        // check for empty label values
+        Optional<Map.Entry<String, String>> emptyValue = labelsAsMap.entrySet().stream()
+            .filter(entry -> entry.getValue().isEmpty())
+            .findFirst();
+        if (emptyValue.isPresent()) {
+            throw new IllegalArgumentException(
+                "Label values cannot be empty, offending label: " + emptyValue.get().getKey()
+            );
         }
 
         Map<String, String> newLabels = ListUtils.emptyOnNull(execution.getLabels()).stream()
@@ -140,6 +155,7 @@ public class Labels extends Task implements ExecutionUpdatableTask {
         newLabels.putAll(labelsAsMap);
 
         return execution.withLabels(newLabels.entrySet().stream()
+            .filter(Label.getEntryNotEmptyPredicate())
             .map(entry -> new Label(
                 entry.getKey(),
                 entry.getValue()

core/src/main/java/io/kestra/plugin/core/flow/ForEachItem.java

@@ -478,7 +478,7 @@ public class ForEachItem extends Task implements FlowableTask<VoidOutput>, Child
             try (InputStream is = runContext.storage().getFile(splitsURI)){
                 String fileContent = new String(is.readAllBytes());
                 List<URI> splits = fileContent.lines().map(line -> URI.create(line)).toList();
-                AtomicInteger currentIteration = new AtomicInteger(1);
+                AtomicInteger currentIteration = new AtomicInteger(0);
 
                 return splits
                     .stream()

core/src/test/java/io/kestra/core/docs/DocumentationGeneratorTest.java

@@ -21,10 +21,13 @@ import java.nio.file.Paths;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
+import org.junit.jupiter.api.parallel.Execution;
+import org.junit.jupiter.api.parallel.ExecutionMode;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
+@Execution(ExecutionMode.SAME_THREAD)
 class DocumentationGeneratorTest {
     @Inject
     JsonSchemaGenerator jsonSchemaGenerator;

core/src/test/java/io/kestra/core/http/client/HttpClientTest.java

@@ -37,6 +37,7 @@ import lombok.Value;
 import org.apache.commons.io.IOUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -67,6 +68,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @KestraTest
 @Testcontainers
+@org.junit.jupiter.api.parallel.Execution(ExecutionMode.SAME_THREAD)
 class HttpClientTest {
     @Inject
     private ApplicationContext applicationContext;

core/src/test/java/io/kestra/core/models/LabelTest.java

@@ -1,19 +1,32 @@
 package io.kestra.core.models;
 
+import io.kestra.core.junit.annotations.KestraTest;
+import io.kestra.core.models.validations.ModelValidator;
+import jakarta.inject.Inject;
+import jakarta.validation.ConstraintViolationException;
 import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+@KestraTest
 class LabelTest {
+    @Inject
+    private ModelValidator modelValidator;
 
     @Test
     void shouldGetNestedMapGivenDistinctLabels() {
         Map<String, Object> result = Label.toNestedMap(List.of(
             new Label(Label.USERNAME, "test"),
-            new Label(Label.CORRELATION_ID, "id"))
+            new Label(Label.CORRELATION_ID, "id"),
+            new Label("", "bar"),
+            new Label(null, "bar"),
+            new Label("foo", ""),
+            new Label("baz", null)
+            )
         );
 
         assertThat(result).isEqualTo(
@@ -34,6 +47,18 @@ class LabelTest {
         );
     }
 
+    @Test
+    void toNestedMapShouldIgnoreEmptyOrNull() {
+        Map<String, Object> result = Label.toNestedMap(List.of(
+            new Label("", "bar"),
+            new Label(null, "bar"),
+            new Label("foo", ""),
+            new Label("baz", null))
+        );
+
+        assertThat(result).isEmpty();
+    }
+
     @Test
     void shouldGetMapGivenDistinctLabels() {
         Map<String, String> result = Label.toMap(List.of(
@@ -59,6 +84,18 @@ class LabelTest {
         );
     }
 
+    @Test
+    void toMapShouldIgnoreEmptyOrNull() {
+        Map<String, String> result = Label.toMap(List.of(
+            new Label("", "bar"),
+            new Label(null, "bar"),
+            new Label("foo", ""),
+            new Label("baz", null))
+        );
+
+        assertThat(result).isEmpty();
+    }
+
     @Test
     void shouldDuplicateLabelsWithKeyOrderKept() {
         List<Label> result = Label.deduplicate(List.of(
@@ -73,4 +110,28 @@ class LabelTest {
             new Label(Label.CORRELATION_ID, "id")
         );
     }
+
+    @Test
+    void deduplicateShouldIgnoreEmptyAndNull() {
+        List<Label> result = Label.deduplicate(List.of(
+            new Label("", "bar"),
+            new Label(null, "bar"),
+            new Label("foo", ""),
+            new Label("baz", null))
+        );
+
+        assertThat(result).isEmpty();
+    }
+
+    @Test
+    void shouldValidateEmpty() {
+        Optional<ConstraintViolationException> validLabelResult = modelValidator.isValid(new Label("foo", "bar"));
+        assertThat(validLabelResult.isPresent()).isFalse();
+
+        Optional<ConstraintViolationException> emptyValueLabelResult = modelValidator.isValid(new Label("foo", ""));
+        assertThat(emptyValueLabelResult.isPresent()).isTrue();
+
+        Optional<ConstraintViolationException> emptyKeyLabelResult = modelValidator.isValid(new Label("", "bar"));
+        assertThat(emptyKeyLabelResult.isPresent()).isTrue();
+    }
 }

core/src/test/java/io/kestra/core/models/executions/ExecutionTest.java

@@ -13,19 +13,19 @@ import java.util.Map;
 import static org.assertj.core.api.Assertions.assertThat;
 
 class ExecutionTest {
-    private static final TaskRun.TaskRunBuilder TASK_RUN = TaskRun.builder()
-        .id("test");
 
     @Test
     void hasTaskRunJoinableTrue() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State(State.Type.RUNNING, new State()))
                 .build())
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State(State.Type.FAILED, new State()
                 .withState(State.Type.RUNNING)
             ))
@@ -36,13 +36,15 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableSameState() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State())
                 .build())
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State())
             .build()
         )).isFalse();
@@ -51,7 +53,8 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableFailedExecutionFromExecutor() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State(State.Type.FAILED, new State()
                     .withState(State.Type.RUNNING)
                 ))
@@ -59,7 +62,8 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State(State.Type.RUNNING, new State()))
             .build()
         )).isFalse();
@@ -68,7 +72,8 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableRestartFailed() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.FAILED)
@@ -77,7 +82,8 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State(State.Type.FAILED, new State()
                 .withState(State.Type.RUNNING)
             ))
@@ -88,7 +94,8 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableRestartSuccess() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.SUCCESS)
@@ -97,7 +104,8 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State(State.Type.SUCCESS, new State()
                 .withState(State.Type.RUNNING)
                 .withState(State.Type.SUCCESS)
@@ -109,7 +117,8 @@ class ExecutionTest {
     @Test
     void hasTaskRunJoinableAfterRestart() {
         Execution execution = Execution.builder()
-            .taskRunList(Collections.singletonList(TASK_RUN
+            .taskRunList(Collections.singletonList(TaskRun.builder()
+                .id("test")
                 .state(new State(State.Type.CREATED, new State()
                     .withState(State.Type.RUNNING)
                     .withState(State.Type.FAILED)
@@ -118,7 +127,8 @@ class ExecutionTest {
             )
             .build();
 
-        assertThat(execution.hasTaskRunJoinable(TASK_RUN
+        assertThat(execution.hasTaskRunJoinable(TaskRun.builder()
+            .id("test")
             .state(new State(State.Type.SUCCESS, new State()
                 .withState(State.Type.RUNNING)
                 .withState(State.Type.FAILED)

core/src/test/java/io/kestra/core/models/executions/StateDurationTest.java

@@ -0,0 +1,55 @@
+package io.kestra.core.models.executions;
+
+import io.kestra.core.models.flows.State;
+import org.junit.jupiter.api.Test;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class StateDurationTest {
+
+
+    private static final Instant NOW = Instant.now();
+    private static final Instant ONE = NOW.minus(Duration.ofDays(1000));
+    private static final Instant TWO = ONE.plus(Duration.ofHours(11));
+    private static final Instant THREE = TWO.plus(Duration.ofHours(222));
+
+    @Test
+    void justCreated() {
+        var state = State.of(
+            State.Type.CREATED,
+            List.of(
+                new State.History(State.Type.CREATED, ONE)
+            )
+        );
+        assertThat(state.getDuration()).isCloseTo(Duration.between(ONE, NOW), Duration.ofMinutes(10));
+    }
+
+    @Test
+    void success() {
+        var state = State.of(
+            State.Type.SUCCESS,
+            List.of(
+                new State.History(State.Type.CREATED, ONE),
+                new State.History(State.Type.RUNNING, TWO),
+                new State.History(State.Type.SUCCESS, THREE)
+            )
+        );
+        assertThat(state.getDuration()).isEqualTo(Duration.between(ONE, THREE));
+    }
+
+    @Test
+    void isRunning() {
+        var state = State.of(
+            State.Type.RUNNING,
+            List.of(
+                new State.History(State.Type.CREATED, ONE),
+                new State.History(State.Type.RUNNING, TWO)
+            )
+        );
+        assertThat(state.getDuration()).isCloseTo(Duration.between(ONE, NOW), Duration.ofMinutes(10));
+    }
+}

core/src/test/java/io/kestra/core/models/hierarchies/FlowGraphTest.java

@@ -7,12 +7,11 @@ import io.kestra.core.junit.annotations.ExecuteFlow;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.junit.annotations.LoadFlows;
 import io.kestra.core.models.executions.Execution;
-import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.FlowWithSource;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.repositories.TriggerRepositoryInterface;
-import io.kestra.core.runners.RunnerUtils;
+import io.kestra.core.runners.TestRunnerUtils;
 import io.kestra.core.serializers.YamlParser;
 import io.kestra.core.services.GraphService;
 import io.kestra.core.utils.GraphUtils;
@@ -45,7 +44,7 @@ class FlowGraphTest {
     private TriggerRepositoryInterface triggerRepositoryInterface;
 
     @Inject
-    private RunnerUtils runnerUtils;
+    private TestRunnerUtils runnerUtils;
 
     @Test
     void simple() throws IllegalVariableEvaluationException, IOException {
@@ -261,10 +260,10 @@ class FlowGraphTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/task-flow.yaml",
-        "flows/valids/switch.yaml"})
+    @LoadFlows(value = {"flows/valids/task-flow.yaml",
+        "flows/valids/switch.yaml"}, tenantId = "tenant1")
     void subflow() throws IllegalVariableEvaluationException, IOException, FlowProcessingException {
-        FlowWithSource flow = this.parse("flows/valids/task-flow.yaml");
+        FlowWithSource flow = this.parse("flows/valids/task-flow.yaml", "tenant1");
         FlowGraph flowGraph = GraphUtils.flowGraph(flow, null);
 
         assertThat(flowGraph.getNodes().size()).isEqualTo(6);
@@ -293,15 +292,15 @@ class FlowGraphTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/task-flow-dynamic.yaml",
-        "flows/valids/switch.yaml"})
+    @LoadFlows(value = {"flows/valids/task-flow-dynamic.yaml",
+        "flows/valids/switch.yaml"}, tenantId = "tenant2")
     void dynamicIdSubflow() throws IllegalVariableEvaluationException, TimeoutException, QueueException, IOException, FlowProcessingException {
-        FlowWithSource flow = this.parse("flows/valids/task-flow-dynamic.yaml").toBuilder().revision(1).build();
+        FlowWithSource flow = this.parse("flows/valids/task-flow-dynamic.yaml", "tenant2").toBuilder().revision(1).build();
 
         IllegalArgumentException illegalArgumentException = Assertions.assertThrows(IllegalArgumentException.class, () -> graphService.flowGraph(flow, Collections.singletonList("root.launch")));
         assertThat(illegalArgumentException.getMessage()).isEqualTo("Can't expand subflow task 'launch' because namespace and/or flowId contains dynamic values. This can only be viewed on an execution.");
 
-        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "task-flow-dynamic", 1, (f, e) -> Map.of(
+        Execution execution = runnerUtils.runOne("tenant2", "io.kestra.tests", "task-flow-dynamic", 1, (f, e) -> Map.of(
             "namespace", f.getNamespace(),
             "flowId", "switch"
         ));
@@ -373,13 +372,17 @@ class FlowGraphTest {
     }
 
     private FlowWithSource parse(String path) throws IOException {
+        return parse(path, MAIN_TENANT);
+    }
+
+    private FlowWithSource parse(String path, String tenantId) throws IOException {
         URL resource = TestsUtils.class.getClassLoader().getResource(path);
         assert resource != null;
 
         File file = new File(resource.getFile());
 
         return YamlParser.parse(file, FlowWithSource.class).toBuilder()
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenantId)
             .source(Files.readString(file.toPath()))
             .build();
     }

core/src/test/java/io/kestra/core/models/property/URIFetcherTest.java

@@ -4,6 +4,7 @@ import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.runners.*;
 import io.kestra.core.storages.StorageContext;
 import io.kestra.core.storages.StorageInterface;
+import io.kestra.core.utils.IdUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
@@ -84,8 +85,9 @@ class URIFetcherTest {
 
     @Test
     void shouldFetchFromNsfile() throws IOException {
-        URI uri = createNsFile(false);
-        RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", "namespace")));
+        String namespace = IdUtils.create();
+        URI uri = createNsFile(namespace, false);
+        RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", namespace)));
 
         try (var fetch = URIFetcher.of(uri).fetch(runContext)) {
             String fetchedContent = new String(fetch.readAllBytes());
@@ -95,7 +97,8 @@ class URIFetcherTest {
 
     @Test
     void shouldFetchFromNsfileFromOtherNs() throws IOException {
-        URI uri = createNsFile(true);
+        String namespace = IdUtils.create();
+        URI uri = createNsFile(namespace, true);
         RunContext runContext = runContextFactory.of(Map.of("flow", Map.of("namespace", "other")));
 
         try (var fetch = URIFetcher.of(uri).fetch(runContext)) {
@@ -139,8 +142,7 @@ class URIFetcherTest {
         );
     }
 
-    private URI createNsFile(boolean nsInAuthority) throws IOException {
-        String namespace = "namespace";
+    private URI createNsFile(String namespace, boolean nsInAuthority) throws IOException {
         String filePath = "file.txt";
         storage.createDirectory(MAIN_TENANT, namespace, URI.create(StorageContext.namespaceFilePrefix(namespace)));
         storage.put(MAIN_TENANT, namespace, URI.create(StorageContext.namespaceFilePrefix(namespace) + "/" + filePath), new ByteArrayInputStream("Hello World".getBytes()));

core/src/test/java/io/kestra/core/models/tasks/runners/ScriptServiceTest.java

@@ -10,6 +10,7 @@ import io.kestra.core.models.tasks.Task;
 import io.kestra.core.runners.RunContext;
 import io.kestra.core.runners.RunContextFactory;
 import io.kestra.core.junit.annotations.KestraTest;
+import io.kestra.core.utils.IdUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
@@ -33,17 +34,15 @@ class ScriptServiceTest {
 
     @Test
     void replaceInternalStorage() throws IOException {
-        var runContext = runContextFactory.of();
+        String tenant = IdUtils.create();
+        var runContext = runContextFactory.of("id", "namespace", tenant);
         var command  = ScriptService.replaceInternalStorage(runContext, null, false);
         assertThat(command).isEqualTo("");
 
         command = ScriptService.replaceInternalStorage(runContext, "my command", false);
         assertThat(command).isEqualTo("my command");
 
-        Path path = Path.of("/tmp/unittest/main/file.txt");
-        if (!path.toFile().exists()) {
-            Files.createFile(path);
-        }
+        Path path = createFile(tenant, "file");
 
         String internalStorageUri = "kestra://some/file.txt";
         File localFile = null;
@@ -70,12 +69,10 @@ class ScriptServiceTest {
 
     @Test
     void replaceInternalStorageUnicode() throws IOException {
-        var runContext = runContextFactory.of();
+        String tenant = IdUtils.create();
+        var runContext = runContextFactory.of("id", "namespace", tenant);
 
-        Path path = Path.of("/tmp/unittest/main/file-龍.txt");
-        if (!path.toFile().exists()) {
-            Files.createFile(path);
-        }
+        Path path = createFile(tenant, "file-龍");
 
         String internalStorageUri = "kestra://some/file-龍.txt";
         File localFile = null;
@@ -95,12 +92,10 @@ class ScriptServiceTest {
 
     @Test
     void uploadInputFiles() throws IOException {
-        var runContext = runContextFactory.of();
+        String tenant = IdUtils.create();
+        var runContext = runContextFactory.of("id", "namespace", tenant);
 
-        Path path = Path.of("/tmp/unittest/main/file.txt");
-        if (!path.toFile().exists()) {
-            Files.createFile(path);
-        }
+        Path path = createFile(tenant, "file");
 
         List<File> filesToDelete = new ArrayList<>();
         String internalStorageUri = "kestra://some/file.txt";
@@ -143,13 +138,11 @@ class ScriptServiceTest {
 
     @Test
     void uploadOutputFiles() throws IOException {
-        var runContext = runContextFactory.of();
-        Path path = Path.of("/tmp/unittest/main/file.txt");
-        if (!path.toFile().exists()) {
-            Files.createFile(path);
-        }
+        String tenant = IdUtils.create();
+        var runContext = runContextFactory.of("id", "namespace", tenant);
+        Path path = createFile(tenant, "file");
 
-        var outputFiles = ScriptService.uploadOutputFiles(runContext, Path.of("/tmp/unittest/main"));
+        var outputFiles = ScriptService.uploadOutputFiles(runContext, Path.of("/tmp/unittest/%s".formatted(tenant)));
         assertThat(outputFiles, not(anEmptyMap()));
         assertThat(outputFiles.get("file.txt")).isEqualTo(URI.create("kestra:///file.txt"));
 
@@ -232,4 +225,13 @@ class ScriptServiceTest {
             .build();
         return runContextFactory.of(flow, task, execution, taskRun);
     }
+
+    private static Path createFile(String tenant, String fileName) throws IOException {
+        Path path = Path.of("/tmp/unittest/%s/%s.txt".formatted(tenant, fileName));
+        if (!path.toFile().exists()) {
+            Files.createDirectory(Path.of("/tmp/unittest/%s".formatted(tenant)));
+            Files.createFile(path);
+        }
+        return path;
+    }
 }

core/src/test/java/io/kestra/core/models/triggers/multipleflows/AbstractMultipleConditionStorageTest.java

@@ -3,6 +3,7 @@ package io.kestra.core.models.triggers.multipleflows;
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.models.property.Property;
+import io.kestra.core.utils.TestsUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.junit.jupiter.api.Test;
 import io.kestra.plugin.core.condition.ExecutionFlow;
@@ -33,8 +34,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void allDefault() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -50,8 +52,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void daily() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofSeconds(0)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofSeconds(0)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -67,8 +70,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void dailyAdvance() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofHours(4).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofDays(1)).windowAdvance(Duration.ofHours(4).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -84,8 +88,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void hourly() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofHours(1)).windowAdvance(Duration.ofHours(4).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofHours(1)).windowAdvance(Duration.ofHours(4).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -102,8 +107,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void minutely() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofMinutes(15)).windowAdvance(Duration.ofMinutes(5).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofMinutes(15)).windowAdvance(Duration.ofMinutes(5).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
 
@@ -115,8 +121,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void expiration() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -136,8 +143,9 @@ public abstract class AbstractMultipleConditionStorageTest {
     @Test
     void expired() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().window(Duration.ofSeconds(2)).windowAdvance(Duration.ofMinutes(0).negated()).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -146,20 +154,21 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isZero();
 
         Thread.sleep(2005);
 
-        expired = multipleConditionStorage.expired(null);
+        expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
     void dailyTimeDeadline() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().plusSeconds(2)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().plusSeconds(2)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -168,20 +177,21 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isZero();
 
         Thread.sleep(2005);
 
-        expired = multipleConditionStorage.expired(null);
+        expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
     void dailyTimeDeadline_Expired() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().minusSeconds(1)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_DEADLINE).deadline(LocalTime.now().minusSeconds(1)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -190,16 +200,17 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults()).isEmpty();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isEqualTo(1);
     }
 
     @Test
-    void dailyTimeWindow() throws Exception {
+    void dailyTimeWindow() {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
         LocalTime startTime = LocalTime.now().truncatedTo(ChronoUnit.MINUTES);
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.DAILY_TIME_WINDOW).startTime(startTime).endTime(startTime.plusMinutes(5)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.DAILY_TIME_WINDOW).startTime(startTime).endTime(startTime.plusMinutes(5)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -208,15 +219,16 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isZero();
     }
 
     @Test
     void slidingWindow() throws Exception {
         MultipleConditionStorageInterface multipleConditionStorage = multipleConditionStorage();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
 
-        Pair<Flow, MultipleCondition> pair = mockFlow(TimeWindow.builder().type(Type.SLIDING_WINDOW).window(Duration.ofHours(1)).build());
+        Pair<Flow, MultipleCondition> pair = mockFlow(tenant, TimeWindow.builder().type(Type.SLIDING_WINDOW).window(Duration.ofHours(1)).build());
 
         MultipleConditionWindow window = multipleConditionStorage.getOrCreate(pair.getKey(), pair.getRight(), Collections.emptyMap());
         this.save(multipleConditionStorage, pair.getLeft(), Collections.singletonList(window.with(ImmutableMap.of("a", true))));
@@ -225,13 +237,13 @@ public abstract class AbstractMultipleConditionStorageTest {
 
         assertThat(window.getResults().get("a")).isTrue();
 
-        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(null);
+        List<MultipleConditionWindow> expired = multipleConditionStorage.expired(tenant);
         assertThat(expired.size()).isZero();
     }
 
-    private static Pair<Flow, MultipleCondition> mockFlow(TimeWindow sla) {
+    private static Pair<Flow, MultipleCondition> mockFlow(String tenantId, TimeWindow sla) {
         var multipleCondition = MultipleCondition.builder()
-            .id("condition-multiple")
+            .id("condition-multiple-%s".formatted(tenantId))
             .conditions(ImmutableMap.of(
                 "flow-a", ExecutionFlow.builder()
                     .flowId(Property.ofValue("flow-a"))
@@ -248,6 +260,7 @@ public abstract class AbstractMultipleConditionStorageTest {
         Flow flow = Flow.builder()
             .namespace(NAMESPACE)
             .id("multiple-flow")
+            .tenantId(tenantId)
             .revision(1)
             .triggers(Collections.singletonList(io.kestra.plugin.core.trigger.Flow.builder()
                 .id("trigger-flow")

core/src/test/java/io/kestra/core/reporter/reports/AbstractFeatureUsageReportTest.java

@@ -13,21 +13,20 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
 public abstract class AbstractFeatureUsageReportTest {
-    
+
     @Inject
     FeatureUsageReport featureUsageReport;
-    
+
     @Test
     public void shouldGetReport() {
         // When
         Instant now = Instant.now();
         FeatureUsageReport.UsageEvent event = featureUsageReport.report(
-            now, 
+            now,
             Reportable.TimeInterval.of(now.minus(Duration.ofDays(1)).atZone(ZoneId.systemDefault()), now.atZone(ZoneId.systemDefault()))
         );
-        
+
         // Then
         assertThat(event.getExecutions().getDailyExecutionsCount().size()).isGreaterThan(0);
-        assertThat(event.getExecutions().getDailyTaskRunsCount()).isNull();
     }
 }

core/src/test/java/io/kestra/core/reporter/reports/SystemInformationReportTest.java

@@ -18,10 +18,10 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
 class SystemInformationReportTest {
-    
+
     @Inject
     private SystemInformationReport systemInformationReport;
-    
+
     @Test
     void shouldGetReport() {
         SystemInformationReport.SystemInformationEvent event = systemInformationReport.report(Instant.now());
@@ -32,34 +32,34 @@ class SystemInformationReportTest {
         assertThat(event.host().getHardware().getLogicalProcessorCount()).isNotNull();
         assertThat(event.host().getJvm().getName()).isNotNull();
         assertThat(event.host().getOs().getFamily()).isNotNull();
-        assertThat(event.configurations().getRepositoryType()).isEqualTo("memory");
-        assertThat(event.configurations().getQueueType()).isEqualTo("memory");
+        assertThat(event.configurations().getRepositoryType()).isEqualTo("h2");
+        assertThat(event.configurations().getQueueType()).isEqualTo("h2");
     }
-    
+
     @MockBean(SettingRepositoryInterface.class)
     @Singleton
     static class TestSettingRepository implements SettingRepositoryInterface {
         public static Object UUID = null;
-        
+
         @Override
         public Optional<Setting> findByKey(String key) {
             return Optional.empty();
         }
-        
+
         @Override
         public List<Setting> findAll() {
             return new ArrayList<>();
         }
-        
+
         @Override
         public Setting save(Setting setting) throws ConstraintViolationException {
             if (setting.getKey().equals(Setting.INSTANCE_UUID)) {
                 UUID = setting.getValue();
             }
-            
+
             return setting;
         }
-        
+
         @Override
         public Setting delete(Setting setting) {
             return setting;

core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java

@@ -25,6 +25,7 @@ import io.kestra.core.models.tasks.ResolvedTask;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.utils.IdUtils;
 import io.kestra.core.utils.NamespaceUtils;
+import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.dashboard.data.Executions;
 import io.kestra.plugin.core.debug.Return;
 import io.micronaut.data.model.Pageable;
@@ -48,7 +49,6 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.USER;
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.doReturn;
@@ -62,17 +62,17 @@ public abstract class AbstractExecutionRepositoryTest {
     @Inject
     protected ExecutionRepositoryInterface executionRepository;
 
-    public static Execution.ExecutionBuilder builder(State.Type state, String flowId) {
-        return builder(state, flowId, NAMESPACE);
+    public static Execution.ExecutionBuilder builder(String tenantId, State.Type state, String flowId) {
+        return builder(tenantId, state, flowId, NAMESPACE);
     }
 
-    public static Execution.ExecutionBuilder builder(State.Type state, String flowId, String namespace) {
+    public static Execution.ExecutionBuilder builder(String tenantId, State.Type state, String flowId, String namespace) {
         State finalState = randomDuration(state);
 
         Execution.ExecutionBuilder execution = Execution.builder()
             .id(FriendlyId.createFriendlyId())
             .namespace(namespace)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenantId)
             .flowId(flowId == null ? FLOW : flowId)
             .flowRevision(1)
             .state(finalState);
@@ -126,11 +126,11 @@ public abstract class AbstractExecutionRepositoryTest {
         return finalState;
     }
 
-    protected void inject() {
-        inject(null);
+    protected void inject(String tenantId) {
+        inject(tenantId, null);
     }
 
-    protected void inject(String executionTriggerId) {
+    protected void inject(String tenantId, String executionTriggerId) {
         ExecutionTrigger executionTrigger = null;
 
         if (executionTriggerId != null) {
@@ -139,7 +139,7 @@ public abstract class AbstractExecutionRepositoryTest {
                 .build();
         }
 
-        executionRepository.save(builder(State.Type.RUNNING, null)
+        executionRepository.save(builder(tenantId, State.Type.RUNNING, null)
             .labels(List.of(
                 new Label("key", "value"),
                 new Label("key2", "value2")
@@ -149,6 +149,7 @@ public abstract class AbstractExecutionRepositoryTest {
         );
         for (int i = 1; i < 28; i++) {
             executionRepository.save(builder(
+                tenantId,
                 i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
                 i < 15 ? null : "second"
             ).trigger(executionTrigger).build());
@@ -156,6 +157,7 @@ public abstract class AbstractExecutionRepositoryTest {
 
         // add a test execution, this should be ignored in search & statistics
         executionRepository.save(builder(
+            tenantId,
             State.Type.SUCCESS,
             null
         )
@@ -167,9 +169,10 @@ public abstract class AbstractExecutionRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter, int expectedSize){
-        inject("executionTriggerId");
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        inject(tenant, "executionTriggerId");
 
-        ArrayListTotal<Execution> entries = executionRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
+        ArrayListTotal<Execution> entries = executionRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
 
         assertThat(entries).hasSize(expectedSize);
     }
@@ -192,7 +195,8 @@ public abstract class AbstractExecutionRepositoryTest {
     @ParameterizedTest
     @MethodSource("errorFilterCombinations")
     void should_fail_to_find_all(QueryFilter filter){
-        assertThrows(InvalidQueryFiltersException.class, () -> executionRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        assertThrows(InvalidQueryFiltersException.class, () -> executionRepository.find(Pageable.UNPAGED, tenant, List.of(filter)));
     }
 
     static Stream<QueryFilter> errorFilterCombinations() {
@@ -208,9 +212,10 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void find() {
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        inject(tenant);
 
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, null);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10),  tenant, null);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
 
@@ -219,7 +224,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value( List.of(State.Type.RUNNING, State.Type.FAILED))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(8L);
 
         filters = List.of(QueryFilter.builder()
@@ -227,7 +232,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(1L);
 
         filters = List.of(QueryFilter.builder()
@@ -235,7 +240,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value2"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(0L);
 
         filters = List.of(QueryFilter.builder()
@@ -244,7 +249,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(Map.of("key", "value", "keyTest", "valueTest"))
             .build()
         );
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(0L);
 
         filters = List.of(QueryFilter.builder()
@@ -252,7 +257,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value("second")
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(13L);
 
         filters = List.of(QueryFilter.builder()
@@ -266,7 +271,7 @@ public abstract class AbstractExecutionRepositoryTest {
                 .value(NAMESPACE)
                 .build()
         );
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(13L);
 
         filters = List.of(QueryFilter.builder()
@@ -274,7 +279,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.STARTS_WITH)
             .value("io.kestra")
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
     }
 
@@ -282,15 +287,16 @@ public abstract class AbstractExecutionRepositoryTest {
     protected void findTriggerExecutionId() {
         String executionTriggerId = IdUtils.create();
 
-        inject(executionTriggerId);
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        inject(tenant, executionTriggerId);
+        inject(tenant);
 
         var filters = List.of(QueryFilter.builder()
             .field(QueryFilter.Field.TRIGGER_EXECUTION_ID)
             .operation(QueryFilter.Op.EQUALS)
             .value(executionTriggerId)
             .build());
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10), MAIN_TENANT, filters);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10), tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger().getVariables().get("executionId")).isEqualTo(executionTriggerId);
@@ -300,7 +306,7 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(ExecutionRepositoryInterface.ChildFilter.CHILD)
             .build());
 
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger().getVariables().get("executionId")).isEqualTo(executionTriggerId);
@@ -311,20 +317,21 @@ public abstract class AbstractExecutionRepositoryTest {
             .value(ExecutionRepositoryInterface.ChildFilter.MAIN)
             .build());
 
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters );
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters );
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
         assertThat(executions.getFirst().getTrigger()).isNull();
 
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, null);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, null);
         assertThat(executions.getTotal()).isEqualTo(56L);
     }
 
     @Test
     protected void findWithSort() {
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        inject(tenant);
 
-        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10, Sort.of(Sort.Order.desc("id"))),  MAIN_TENANT, null);
+        ArrayListTotal<Execution> executions = executionRepository.find(Pageable.from(1, 10, Sort.of(Sort.Order.desc("id"))),  tenant, null);
         assertThat(executions.getTotal()).isEqualTo(28L);
         assertThat(executions.size()).isEqualTo(10);
 
@@ -333,114 +340,107 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(List.of(State.Type.RUNNING, State.Type.FAILED))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.getTotal()).isEqualTo(8L);
     }
 
-    @Test
-    protected void findTaskRun() {
-        inject();
-
-        ArrayListTotal<TaskRun> taskRuns = executionRepository.findTaskRun(Pageable.from(1, 10), MAIN_TENANT, null);
-        assertThat(taskRuns.getTotal()).isEqualTo(74L);
-        assertThat(taskRuns.size()).isEqualTo(10);
-
-        var filters = List.of(QueryFilter.builder()
-            .field(QueryFilter.Field.LABELS)
-            .operation(QueryFilter.Op.EQUALS)
-            .value(Map.of("key", "value"))
-            .build());
-
-        taskRuns = executionRepository.findTaskRun(Pageable.from(1, 10), MAIN_TENANT, filters);
-        assertThat(taskRuns.getTotal()).isEqualTo(1L);
-        assertThat(taskRuns.size()).isEqualTo(1);
-    }
-
-
     @Test
     protected void findById() {
-        executionRepository.save(ExecutionFixture.EXECUTION_1);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
+        executionRepository.save(execution1);
 
-        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
+        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
         assertThat(full.isPresent()).isTrue();
 
         full.ifPresent(current -> {
-            assertThat(full.get().getId()).isEqualTo(ExecutionFixture.EXECUTION_1.getId());
+            assertThat(full.get().getId()).isEqualTo(execution1.getId());
         });
     }
 
     @Test
     protected void shouldFindByIdTestExecution() {
-        executionRepository.save(ExecutionFixture.EXECUTION_TEST);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var executionTest = ExecutionFixture.EXECUTION_TEST(tenant);
+        executionRepository.save(executionTest);
 
-        Optional<Execution> full = executionRepository.findById(null, ExecutionFixture.EXECUTION_TEST.getId());
+        Optional<Execution> full = executionRepository.findById(tenant, executionTest.getId());
         assertThat(full.isPresent()).isTrue();
 
         full.ifPresent(current -> {
-            assertThat(full.get().getId()).isEqualTo(ExecutionFixture.EXECUTION_TEST.getId());
+            assertThat(full.get().getId()).isEqualTo(executionTest.getId());
         });
     }
 
     @Test
     protected void purge() {
-        executionRepository.save(ExecutionFixture.EXECUTION_1);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
+        executionRepository.save(execution1);
 
-        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
+        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
         assertThat(full.isPresent()).isTrue();
 
-        executionRepository.purge(ExecutionFixture.EXECUTION_1);
+        executionRepository.purge(execution1);
 
-        full = executionRepository.findById(null, ExecutionFixture.EXECUTION_1.getId());
+        full = executionRepository.findById(tenant, execution1.getId());
         assertThat(full.isPresent()).isFalse();
     }
 
     @Test
     protected void purgeExecutions() {
-        var execution1 = ExecutionFixture.EXECUTION_1;
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
         executionRepository.save(execution1);
-        var execution2 = ExecutionFixture.EXECUTION_2;
+        var execution2 = ExecutionFixture.EXECUTION_2(tenant);
         executionRepository.save(execution2);
 
         var results = executionRepository.purge(List.of(execution1, execution2));
         assertThat(results).isEqualTo(2);
 
-        assertThat(executionRepository.findById(null, execution1.getId())).isEmpty();
-        assertThat(executionRepository.findById(null, execution2.getId())).isEmpty();
+        assertThat(executionRepository.findById(tenant, execution1.getId())).isEmpty();
+        assertThat(executionRepository.findById(tenant, execution2.getId())).isEmpty();
     }
 
     @Test
     protected void delete() {
-        executionRepository.save(ExecutionFixture.EXECUTION_1);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var execution1 = ExecutionFixture.EXECUTION_1(tenant);
+        executionRepository.save(execution1);
 
-        Optional<Execution> full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
+        Optional<Execution> full = executionRepository.findById(tenant, execution1.getId());
         assertThat(full.isPresent()).isTrue();
 
-        executionRepository.delete(ExecutionFixture.EXECUTION_1);
+        executionRepository.delete(execution1);
 
-        full = executionRepository.findById(MAIN_TENANT, ExecutionFixture.EXECUTION_1.getId());
+        full = executionRepository.findById(tenant, execution1.getId());
         assertThat(full.isPresent()).isFalse();
     }
 
     @Test
     protected void mappingConflict() {
-        executionRepository.save(ExecutionFixture.EXECUTION_2);
-        executionRepository.save(ExecutionFixture.EXECUTION_1);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        executionRepository.save(ExecutionFixture.EXECUTION_2(tenant));
+        executionRepository.save(ExecutionFixture.EXECUTION_1(tenant));
 
-        ArrayListTotal<Execution> page1 = executionRepository.findByFlowId(MAIN_TENANT, NAMESPACE, FLOW, Pageable.from(1, 10));
+        ArrayListTotal<Execution> page1 = executionRepository.findByFlowId(tenant, NAMESPACE, FLOW, Pageable.from(1, 10));
 
         assertThat(page1.size()).isEqualTo(2);
     }
 
     @Test
     protected void dailyStatistics() throws InterruptedException {
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         for (int i = 0; i < 28; i++) {
             executionRepository.save(builder(
+                tenant,
                 i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
                 i < 15 ? null : "second"
             ).build());
         }
 
         executionRepository.save(builder(
+            tenant,
             State.Type.SUCCESS,
             "second"
         ).namespace(NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE).build());
@@ -450,15 +450,14 @@ public abstract class AbstractExecutionRepositoryTest {
 
         List<DailyExecutionStatistics> result = executionRepository.dailyStatistics(
             null,
-            MAIN_TENANT,
+            tenant,
             null,
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null,
-            false);
+            null);
 
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().size()).isEqualTo(11);
@@ -470,131 +469,52 @@ public abstract class AbstractExecutionRepositoryTest {
 
         result = executionRepository.dailyStatistics(
             null,
-            MAIN_TENANT,
+            tenant,
             List.of(FlowScope.USER, FlowScope.SYSTEM),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null,
-            false);
+            null);
 
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(21L);
 
         result = executionRepository.dailyStatistics(
             null,
-            MAIN_TENANT,
+            tenant,
             List.of(FlowScope.USER),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null,
-            false);
+            null);
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(20L);
 
         result = executionRepository.dailyStatistics(
             null,
-            MAIN_TENANT,
+            tenant,
             List.of(FlowScope.SYSTEM),
             null,
             null,
             ZonedDateTime.now().minusDays(10),
             ZonedDateTime.now(),
             null,
-            null,
-            false);
+            null);
         assertThat(result.size()).isEqualTo(11);
         assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(1L);
     }
 
-    @Test
-    protected void taskRunsDailyStatistics() {
-        for (int i = 0; i < 28; i++) {
-            executionRepository.save(builder(
-                i < 5 ? State.Type.RUNNING : (i < 8 ? State.Type.FAILED : State.Type.SUCCESS),
-                i < 15 ? null : "second"
-            ).build());
-        }
-
-        executionRepository.save(builder(
-            State.Type.SUCCESS,
-            "second"
-        ).namespace(NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE).build());
-
-        List<DailyExecutionStatistics> result = executionRepository.dailyStatistics(
-            null,
-            MAIN_TENANT,
-            null,
-            null,
-            null,
-            ZonedDateTime.now().minusDays(10),
-            ZonedDateTime.now(),
-            null,
-            null,
-            true);
-
-        assertThat(result.size()).isEqualTo(11);
-        assertThat(result.get(10).getExecutionCounts().size()).isEqualTo(11);
-        assertThat(result.get(10).getDuration().getAvg().toMillis()).isGreaterThan(0L);
-
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.FAILED)).isEqualTo(3L * 2);
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.RUNNING)).isEqualTo(5L * 2);
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(57L);
-
-        result = executionRepository.dailyStatistics(
-            null,
-            MAIN_TENANT,
-            List.of(FlowScope.USER, FlowScope.SYSTEM),
-            null,
-            null,
-            ZonedDateTime.now().minusDays(10),
-            ZonedDateTime.now(),
-            null,
-            null,
-            true);
-
-        assertThat(result.size()).isEqualTo(11);
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(57L);
-
-        result = executionRepository.dailyStatistics(
-            null,
-            MAIN_TENANT,
-            List.of(FlowScope.USER),
-            null,
-            null,
-            ZonedDateTime.now().minusDays(10),
-            ZonedDateTime.now(),
-            null,
-            null,
-            true);
-        assertThat(result.size()).isEqualTo(11);
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(55L);
-
-        result = executionRepository.dailyStatistics(
-            null,
-            MAIN_TENANT,
-            List.of(FlowScope.SYSTEM),
-            null,
-            null,
-            ZonedDateTime.now().minusDays(10),
-            ZonedDateTime.now(),
-            null,
-            null,
-            true);
-        assertThat(result.size()).isEqualTo(11);
-        assertThat(result.get(10).getExecutionCounts().get(State.Type.SUCCESS)).isEqualTo(2L);
-    }
-
     @SuppressWarnings("OptionalGetWithoutIsPresent")
     @Test
     protected void executionsCount() throws InterruptedException {
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         for (int i = 0; i < 14; i++) {
             executionRepository.save(builder(
+                tenant,
                 State.Type.SUCCESS,
                 i < 2 ? "first" : (i < 5 ? "second" : "third")
             ).build());
@@ -604,7 +524,7 @@ public abstract class AbstractExecutionRepositoryTest {
         Thread.sleep(500);
 
         List<ExecutionCount> result = executionRepository.executionCounts(
-            MAIN_TENANT,
+            tenant,
             List.of(
                 new Flow(NAMESPACE, "first"),
                 new Flow(NAMESPACE, "second"),
@@ -623,7 +543,7 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(result.stream().filter(executionCount -> executionCount.getFlowId().equals("missing")).findFirst().get().getCount()).isEqualTo(0L);
 
         result = executionRepository.executionCounts(
-            MAIN_TENANT,
+            tenant,
             List.of(
                 new Flow(NAMESPACE, "first"),
                 new Flow(NAMESPACE, "second"),
@@ -640,7 +560,7 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(result.stream().filter(executionCount -> executionCount.getFlowId().equals("third")).findFirst().get().getCount()).isEqualTo(9L);
 
         result = executionRepository.executionCounts(
-            MAIN_TENANT,
+            tenant,
             null,
             null,
             null,
@@ -653,14 +573,15 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void update() {
-        Execution execution = ExecutionFixture.EXECUTION_1;
-        executionRepository.save(ExecutionFixture.EXECUTION_1);
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Execution execution = ExecutionFixture.EXECUTION_1(tenant);
+        executionRepository.save(execution);
 
         Label label = new Label("key", "value");
         Execution updated = execution.toBuilder().labels(List.of(label)).build();
         executionRepository.update(updated);
 
-        Optional<Execution> validation = executionRepository.findById(MAIN_TENANT, updated.getId());
+        Optional<Execution> validation = executionRepository.findById(tenant, updated.getId());
         assertThat(validation.isPresent()).isTrue();
         assertThat(validation.get().getLabels().size()).isEqualTo(1);
         assertThat(validation.get().getLabels().getFirst()).isEqualTo(label);
@@ -668,13 +589,14 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     void shouldFindLatestExecutionGivenState() {
-        Execution earliest = buildWithCreatedDate(Instant.now().minus(Duration.ofMinutes(10)));
-        Execution latest = buildWithCreatedDate(Instant.now().minus(Duration.ofMinutes(5)));
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Execution earliest = buildWithCreatedDate(tenant, Instant.now().minus(Duration.ofMinutes(10)));
+        Execution latest = buildWithCreatedDate(tenant, Instant.now().minus(Duration.ofMinutes(5)));
 
         executionRepository.save(earliest);
         executionRepository.save(latest);
 
-        Optional<Execution> result = executionRepository.findLatestForStates(MAIN_TENANT, "io.kestra.unittest", "full", List.of(State.Type.CREATED));
+        Optional<Execution> result = executionRepository.findLatestForStates(tenant, "io.kestra.unittest", "full", List.of(State.Type.CREATED));
         assertThat(result.isPresent()).isTrue();
         assertThat(result.get().getId()).isEqualTo(latest.getId());
     }
@@ -714,11 +636,11 @@ public abstract class AbstractExecutionRepositoryTest {
         assertThat(data.get(0).get("date")).isEqualTo(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSXXX").format(ZonedDateTime.ofInstant(startDate, ZoneId.systemDefault()).withSecond(0).withNano(0)));
     }
 
-    private static Execution buildWithCreatedDate(Instant instant) {
+    private static Execution buildWithCreatedDate(String tenant, Instant instant) {
         return Execution.builder()
             .id(IdUtils.create())
             .namespace("io.kestra.unittest")
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .flowId("full")
             .flowRevision(1)
             .state(new State(State.Type.CREATED, List.of(new State.History(State.Type.CREATED, instant))))
@@ -729,22 +651,24 @@ public abstract class AbstractExecutionRepositoryTest {
 
     @Test
     protected void findAllAsync() {
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+inject(tenant);
 
-        List<Execution> executions = executionRepository.findAllAsync(MAIN_TENANT).collectList().block();
+        List<Execution> executions = executionRepository.findAllAsync(tenant).collectList().block();
         assertThat(executions).hasSize(29); // used by the backup so it contains TEST executions
     }
 
     @Test
     protected void shouldFindByLabel() {
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+inject(tenant);
 
         List<QueryFilter> filters = List.of(QueryFilter.builder()
             .field(QueryFilter.Field.LABELS)
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value"))
             .build());
-        List<Execution> executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        List<Execution> executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.size()).isEqualTo(1L);
 
         // Filtering by two pairs of labels, since now its a and behavior, it should not return anything
@@ -753,19 +677,107 @@ public abstract class AbstractExecutionRepositoryTest {
             .operation(QueryFilter.Op.EQUALS)
             .value(Map.of("key", "value", "keyother", "valueother"))
             .build());
-        executions = executionRepository.find(Pageable.from(1, 10),  MAIN_TENANT, filters);
+        executions = executionRepository.find(Pageable.from(1, 10),  tenant, filters);
         assertThat(executions.size()).isEqualTo(0L);
     }
 
     @Test
     protected void shouldReturnLastExecutionsWhenInputsAreNull() {
-        inject();
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        inject(tenant);
 
-        List<Execution> lastExecutions = executionRepository.lastExecutions(MAIN_TENANT, null);
+        List<Execution> lastExecutions = executionRepository.lastExecutions(tenant, null);
 
         assertThat(lastExecutions).isNotEmpty();
         Set<String> flowIds = lastExecutions.stream().map(Execution::getFlowId).collect(Collectors.toSet());
         assertThat(flowIds.size()).isEqualTo(lastExecutions.size());
     }
 
+    private static final Instant NOW = Instant.now();
+    private static final Instant INSTANT_ONE = NOW.minus(Duration.ofDays(1000));
+    private static final Instant INSTANT_TWO = INSTANT_ONE.plus(Duration.ofHours(11));
+    private static final Instant INSTANT_THREE = INSTANT_TWO.plus(Duration.ofHours(222));
+
+    @Test
+    protected void findShouldSortCorrectlyOnDurationAndDates() {
+        // given
+        var tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var createdExecution = Execution.builder()
+            .id("createdExecution__"+FriendlyId.createFriendlyId())
+            .namespace(NAMESPACE)
+            .tenantId(tenant)
+            .flowId(FLOW)
+            .flowRevision(1)
+            .state(
+                State.of(
+                    State.Type.CREATED,
+                    List.of(
+                        new State.History(State.Type.CREATED, INSTANT_ONE)
+                    )
+                )
+            ).build();
+        assertThat(createdExecution.getState().getDuration()).isCloseTo(Duration.ofDays(1000), Duration.ofMinutes(10));
+        executionRepository.save(createdExecution);
+
+        var successExecution = Execution.builder()
+            .id("successExecution__"+FriendlyId.createFriendlyId())
+            .namespace(NAMESPACE)
+            .tenantId(tenant)
+            .flowId(FLOW)
+            .flowRevision(1)
+            .state(
+                State.of(
+                    State.Type.SUCCESS,
+                    List.of(
+                        new State.History(State.Type.CREATED, INSTANT_ONE),
+                        new State.History(State.Type.RUNNING, INSTANT_TWO),
+                        new State.History(State.Type.SUCCESS, INSTANT_THREE)
+                    )
+                )
+            ).build();
+        assertThat(successExecution.getState().getDuration()).isCloseTo(Duration.ofHours(233), Duration.ofMinutes(10));
+        executionRepository.save(successExecution);
+
+        var runningExecution = Execution.builder()
+            .id("runningExecution__"+FriendlyId.createFriendlyId())
+            .namespace(NAMESPACE)
+            .tenantId(tenant)
+            .flowId(FLOW)
+            .flowRevision(1)
+            .state(
+                State.of(
+                    State.Type.RUNNING,
+                    List.of(
+                        new State.History(State.Type.CREATED, INSTANT_TWO),
+                        new State.History(State.Type.RUNNING, INSTANT_THREE)
+                    )
+                )
+            ).build();
+        assertThat(runningExecution.getState().getDuration()).isCloseTo(Duration.ofDays(1000).minus(Duration.ofHours(11)), Duration.ofMinutes(10));
+        executionRepository.save(runningExecution);
+
+        // when
+        List<QueryFilter> emptyFilters = null;
+        var sortedByShortestDuration = executionRepository.find(Pageable.from(Sort.of(Sort.Order.asc("state_duration"))), tenant, emptyFilters);
+        // then
+        assertThat(sortedByShortestDuration.stream())
+            .as("assert order when finding by shortest duration")
+            .usingRecursiveFieldByFieldElementComparatorOnFields("id")
+            .containsExactly(
+                successExecution,
+                runningExecution,
+                createdExecution
+            );
+
+        // when
+        var findByMoreRecentStartDate = executionRepository.find(Pageable.from(1,1, Sort.of(Sort.Order.desc("start_date"))), tenant, emptyFilters);
+        // then
+        assertThat(findByMoreRecentStartDate.stream())
+            .as("assert order when finding by last start date")
+            .usingRecursiveFieldByFieldElementComparatorOnFields("id")
+            .containsExactly(
+                runningExecution
+            );
+    }
+
 }

core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java

@@ -1,7 +1,6 @@
 package io.kestra.core.repositories;
 
 import com.google.common.collect.ImmutableMap;
-import io.kestra.core.Helpers;
 import io.kestra.core.events.CrudEvent;
 import io.kestra.core.events.CrudEventType;
 import io.kestra.core.exceptions.InvalidQueryFiltersException;
@@ -10,7 +9,6 @@ import io.kestra.core.models.Label;
 import io.kestra.core.models.QueryFilter;
 import io.kestra.core.models.QueryFilter.Field;
 import io.kestra.core.models.QueryFilter.Op;
-import io.kestra.core.models.SearchResult;
 import io.kestra.core.models.conditions.ConditionContext;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.ExecutionTrigger;
@@ -20,7 +18,6 @@ import io.kestra.core.models.property.Property;
 import io.kestra.core.models.triggers.AbstractTrigger;
 import io.kestra.core.models.triggers.PollingTriggerInterface;
 import io.kestra.core.models.triggers.TriggerContext;
-import io.kestra.core.queues.QueueException;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.services.FlowService;
 import io.kestra.core.utils.Await;
@@ -29,22 +26,18 @@ import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.debug.Return;
 import io.micronaut.context.event.ApplicationEventListener;
 import io.micronaut.data.model.Pageable;
-import io.micronaut.data.model.Sort;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import jakarta.validation.ConstraintViolationException;
+import java.util.concurrent.CopyOnWriteArrayList;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.slf4j.event.Level;
 
-import java.io.IOException;
-import java.net.URISyntaxException;
 import java.time.Duration;
 import java.time.ZonedDateTime;
 import java.util.*;
@@ -52,16 +45,14 @@ import java.util.concurrent.TimeoutException;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.SYSTEM;
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static io.kestra.core.utils.NamespaceUtils.SYSTEM_FLOWS_DEFAULT_NAMESPACE;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-// If some counts are wrong in this test it means that one of the tests is not properly deleting what it created
 @KestraTest
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class AbstractFlowRepositoryTest {
-    public static final String TEST_TENANT_ID = "tenant";
     public static final String TEST_NAMESPACE = "io.kestra.unittest";
     public static final String TEST_FLOW_ID = "test";
     @Inject
@@ -70,21 +61,18 @@ public abstract class AbstractFlowRepositoryTest {
     @Inject
     protected ExecutionRepositoryInterface executionRepository;
 
-    @Inject
-    private LocalFlowRepositoryLoader repositoryLoader;
-
-    @BeforeEach
-    protected void init() throws IOException, URISyntaxException {
-        TestsUtils.loads(MAIN_TENANT, repositoryLoader);
+    @BeforeAll
+    protected static void init() {
         FlowListener.reset();
     }
 
-    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder() {
-        return builder(IdUtils.create(), TEST_FLOW_ID);
+    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String tenantId) {
+        return builder(tenantId, IdUtils.create(), TEST_FLOW_ID);
     }
 
-    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String flowId, String taskId) {
+    private static FlowWithSource.FlowWithSourceBuilder<?, ?> builder(String tenantId, String flowId, String taskId) {
         return FlowWithSource.builder()
+            .tenantId(tenantId)
             .id(flowId)
             .namespace(TEST_NAMESPACE)
             .tasks(Collections.singletonList(Return.builder().id(taskId).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()));
@@ -93,16 +81,16 @@ public abstract class AbstractFlowRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         FlowWithSource flow = FlowWithSource.builder()
             .id("filterFlowId")
             .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .labels(Label.from(Map.of("key", "value")))
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            ArrayListTotal<Flow> entries = flowRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
+            ArrayListTotal<Flow> entries = flowRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
 
             assertThat(entries).hasSize(1);
         } finally {
@@ -113,16 +101,16 @@ public abstract class AbstractFlowRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all_with_source(QueryFilter filter){
-
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         FlowWithSource flow = FlowWithSource.builder()
             .id("filterFlowId")
             .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .labels(Label.from(Map.of("key", "value")))
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            ArrayListTotal<FlowWithSource> entries = flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
+            ArrayListTotal<FlowWithSource> entries = flowRepository.findWithSource(Pageable.UNPAGED, tenant, List.of(filter));
 
             assertThat(entries).hasSize(1);
         } finally {
@@ -144,7 +132,7 @@ public abstract class AbstractFlowRepositoryTest {
     void should_fail_to_find_all(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> flowRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
+            () -> flowRepository.find(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
 
     }
 
@@ -153,7 +141,7 @@ public abstract class AbstractFlowRepositoryTest {
     void should_fail_to_find_all_with_source(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
+            () -> flowRepository.findWithSource(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
 
     }
 
@@ -176,17 +164,17 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findById() {
-        FlowWithSource flow = builder()
-            .tenantId(MAIN_TENANT)
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flow = builder(tenant)
             .revision(3)
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            Optional<Flow> full = flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId());
+            Optional<Flow> full = flowRepository.findById(tenant, flow.getNamespace(), flow.getId());
             assertThat(full.isPresent()).isTrue();
             assertThat(full.get().getRevision()).isEqualTo(1);
 
-            full = flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
+            full = flowRepository.findById(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
         } finally {
             deleteFlow(flow);
@@ -195,17 +183,18 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByIdWithoutAcl() {
-        FlowWithSource flow = builder()
-            .tenantId(MAIN_TENANT)
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flow = builder(tenant)
+            .tenantId(tenant)
             .revision(3)
             .build();
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            Optional<Flow> full = flowRepository.findByIdWithoutAcl(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
+            Optional<Flow> full = flowRepository.findByIdWithoutAcl(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
             assertThat(full.get().getRevision()).isEqualTo(1);
 
-            full = flowRepository.findByIdWithoutAcl(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.empty());
+            full = flowRepository.findByIdWithoutAcl(tenant, flow.getNamespace(), flow.getId(), Optional.empty());
             assertThat(full.isPresent()).isTrue();
         } finally {
             deleteFlow(flow);
@@ -214,15 +203,16 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByIdWithSource() {
-        FlowWithSource flow = builder()
-            .tenantId(MAIN_TENANT)
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flow = builder(tenant)
+            .tenantId(tenant)
             .revision(3)
             .build();
         String source = "# comment\n" + flow.sourceOrGenerateIfNull();
-        flow = flowRepository.create(GenericFlow.fromYaml(MAIN_TENANT, source));
+        flow = flowRepository.create(GenericFlow.fromYaml(tenant, source));
 
         try {
-            Optional<FlowWithSource> full = flowRepository.findByIdWithSource(MAIN_TENANT, flow.getNamespace(), flow.getId());
+            Optional<FlowWithSource> full = flowRepository.findByIdWithSource(tenant, flow.getNamespace(), flow.getId());
             assertThat(full.isPresent()).isTrue();
 
             full.ifPresent(current -> {
@@ -237,7 +227,8 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void save() {
-        FlowWithSource flow = builder().revision(12).build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flow = builder(tenant).revision(12).build();
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
@@ -249,7 +240,8 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void saveNoRevision() {
-        FlowWithSource flow = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flow = builder(tenant).build();
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
@@ -260,56 +252,17 @@ public abstract class AbstractFlowRepositoryTest {
 
     }
 
-    @Test
-    void findAll() {
-        List<Flow> save = flowRepository.findAll(MAIN_TENANT);
-
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void findAllWithSource() {
-        List<FlowWithSource> save = flowRepository.findAllWithSource(MAIN_TENANT);
-
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void findAllForAllTenants() {
-        List<Flow> save = flowRepository.findAllForAllTenants();
-
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void findAllWithSourceForAllTenants() {
-        List<FlowWithSource> save = flowRepository.findAllWithSourceForAllTenants();
-
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void findByNamespacePrefix() {
-        List<Flow> save = flowRepository.findByNamespacePrefix(MAIN_TENANT, "io.kestra.tests");
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT - 1);
-
-        save = flowRepository.findByNamespace(MAIN_TENANT, "io.kestra.tests2");
-        assertThat((long) save.size()).isEqualTo(1L);
-
-        save = flowRepository.findByNamespace(MAIN_TENANT, "io.kestra.tests.minimal.bis");
-        assertThat((long) save.size()).isEqualTo(1L);
-    }
-
     @Test
     void findByNamespaceWithSource() {
-        Flow flow = builder()
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Flow flow = builder(tenant)
             .revision(3)
             .build();
         String flowSource = "# comment\n" + flow.sourceOrGenerateIfNull();
-        flow = flowRepository.create(GenericFlow.fromYaml(MAIN_TENANT, flowSource));
+        flow = flowRepository.create(GenericFlow.fromYaml(tenant, flowSource));
 
         try {
-            List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(MAIN_TENANT, flow.getNamespace());
+            List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(tenant, flow.getNamespace());
             assertThat((long) save.size()).isEqualTo(1L);
 
             assertThat(save.getFirst().getSource()).isEqualTo(FlowService.cleanupSource(flowSource));
@@ -318,175 +271,15 @@ public abstract class AbstractFlowRepositoryTest {
         }
     }
 
-    @Test
-    void findByNamespacePrefixWithSource() {
-        List<FlowWithSource> save = flowRepository.findByNamespacePrefixWithSource(MAIN_TENANT, "io.kestra.tests");
-        assertThat((long) save.size()).isEqualTo(Helpers.FLOWS_COUNT - 1);
-    }
-
-    @Test
-    void find_paginationPartial() {
-        assertThat(flowRepository.find(Pageable.from(1, (int) Helpers.FLOWS_COUNT - 1, Sort.UNSORTED), MAIN_TENANT, null)
-            .size())
-            .describedAs("When paginating at MAX-1, it should return MAX-1")
-            .isEqualTo(Helpers.FLOWS_COUNT - 1);
-
-        assertThat(flowRepository.findWithSource(Pageable.from(1, (int) Helpers.FLOWS_COUNT - 1, Sort.UNSORTED), MAIN_TENANT, null)
-            .size())
-            .describedAs("When paginating at MAX-1, it should return MAX-1")
-            .isEqualTo(Helpers.FLOWS_COUNT - 1);
-    }
-
-    @Test
-    void find_paginationGreaterThanExisting() {
-        assertThat(flowRepository.find(Pageable.from(1, (int) Helpers.FLOWS_COUNT + 1, Sort.UNSORTED), MAIN_TENANT, null)
-            .size())
-            .describedAs("When paginating requesting a larger amount than existing, it should return existing MAX")
-            .isEqualTo(Helpers.FLOWS_COUNT);
-        assertThat(flowRepository.findWithSource(Pageable.from(1, (int) Helpers.FLOWS_COUNT + 1, Sort.UNSORTED), MAIN_TENANT, null)
-            .size())
-            .describedAs("When paginating requesting a larger amount than existing, it should return existing MAX")
-            .isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void find_prefixMatchingAllNamespaces() {
-        assertThat(flowRepository.find(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.STARTS_WITH).value("io.kestra.tests").build()
-            )
-        ).size())
-            .describedAs("When filtering on NAMESPACE START_WITH a pattern that match all, it should return all")
-            .isEqualTo(Helpers.FLOWS_COUNT);
-
-        assertThat(flowRepository.findWithSource(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.STARTS_WITH).value("io.kestra.tests").build()
-            )
-        ).size())
-            .describedAs("When filtering on NAMESPACE START_WITH a pattern that match all, it should return all")
-            .isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
-    @Test
-    void find_aSpecifiedNamespace() {
-        assertThat(flowRepository.find(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests2").build()
-            )
-        ).size()).isEqualTo(1L);
-
-        assertThat(flowRepository.findWithSource(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests2").build()
-            )
-        ).size()).isEqualTo(1L);
-    }
-
-    @Test
-    void find_aSpecificSubNamespace() {
-        assertThat(flowRepository.find(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests.minimal.bis").build()
-            )
-        ).size())
-            .isEqualTo(1L);
-
-        assertThat(flowRepository.findWithSource(
-            Pageable.UNPAGED,
-            MAIN_TENANT,
-            List.of(
-                QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests.minimal.bis").build()
-            )
-        ).size())
-            .isEqualTo(1L);
-    }
-
-    @Test
-    void find_aSpecificLabel() {
-        assertThat(
-            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("country", "FR")).build()
-                )
-            ).size())
-            .isEqualTo(1);
-
-        assertThat(
-            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("country", "FR")).build()
-                )
-            ).size())
-            .isEqualTo(1);
-    }
-
-    @Test
-    void find_aSpecificFlowByNamespaceAndLabel() {
-        assertThat(
-            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key2", "value2")).build()
-                )
-            ).size())
-            .isEqualTo(1);
-
-        assertThat(
-            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key2", "value2")).build()
-                )
-            ).size())
-            .isEqualTo(1);
-    }
-
-    @Test
-    void find_noResult_forAnUnknownNamespace() {
-        assertThat(
-            flowRepository.find(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key1", "value2")).build()
-                )
-            ).size())
-            .isEqualTo(0);
-
-        assertThat(
-            flowRepository.findWithSource(Pageable.UNPAGED, MAIN_TENANT,
-                List.of(
-                    QueryFilter.builder().field(QueryFilter.Field.NAMESPACE).operation(QueryFilter.Op.EQUALS).value("io.kestra.tests").build(),
-                    QueryFilter.builder().field(QueryFilter.Field.LABELS).operation(QueryFilter.Op.EQUALS).value(Map.of("key1", "value2")).build()
-                )
-            ).size())
-            .isEqualTo(0);
-    }
-
-    @Test
-    protected void findSpecialChars() {
-        ArrayListTotal<SearchResult<Flow>> save = flowRepository.findSourceCode(Pageable.unpaged(), "https://api.chucknorris.io", MAIN_TENANT, null);
-        assertThat((long) save.size()).isEqualTo(2L);
-    }
-
     @Test
     void delete() {
-        Flow flow = builder().tenantId(MAIN_TENANT).build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Flow flow = builder(tenant).tenantId(tenant).build();
 
         FlowWithSource save = flowRepository.create(GenericFlow.of(flow));
 
         try {
-            assertThat(flowRepository.findById(MAIN_TENANT, save.getNamespace(), save.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(tenant, save.getNamespace(), save.getId()).isPresent()).isTrue();
         } catch (Throwable e) {
             deleteFlow(save);
             throw e;
@@ -494,21 +287,22 @@ public abstract class AbstractFlowRepositoryTest {
 
         Flow delete = flowRepository.delete(save);
 
-        assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isFalse();
-        assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId(), Optional.of(save.getRevision())).isPresent()).isTrue();
+        assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isFalse();
+        assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId(), Optional.of(save.getRevision())).isPresent()).isTrue();
 
-        List<FlowWithSource> revisions = flowRepository.findRevisions(MAIN_TENANT, flow.getNamespace(), flow.getId());
+        List<FlowWithSource> revisions = flowRepository.findRevisions(tenant, flow.getNamespace(), flow.getId());
         assertThat(revisions.getLast().getRevision()).isEqualTo(delete.getRevision());
     }
 
     @Test
     void updateConflict() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .inputs(List.of(StringInput.builder().type(Type.STRING).id("a").build()))
             .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
             .build();
@@ -516,12 +310,12 @@ public abstract class AbstractFlowRepositoryTest {
         Flow save = flowRepository.create(GenericFlow.of(flow));
 
         try {
-            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
 
             Flow update = Flow.builder()
                 .id(IdUtils.create())
                 .namespace("io.kestra.unittest2")
-                .tenantId(MAIN_TENANT)
+                .tenantId(tenant)
                 .inputs(List.of(StringInput.builder().type(Type.STRING).id("b").build()))
                 .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
                 .build();
@@ -539,13 +333,14 @@ public abstract class AbstractFlowRepositoryTest {
     }
 
     @Test
-    void removeTrigger() throws TimeoutException, QueueException {
+    public void removeTrigger() throws TimeoutException {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .triggers(Collections.singletonList(UnitTest.builder()
                 .id("sleep")
                 .type(UnitTest.class.getName())
@@ -555,12 +350,12 @@ public abstract class AbstractFlowRepositoryTest {
 
         flow = flowRepository.create(GenericFlow.of(flow));
         try {
-            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
 
             Flow update = Flow.builder()
                 .id(flowId)
                 .namespace(TEST_NAMESPACE)
-                .tenantId(MAIN_TENANT)
+                .tenantId(tenant)
                 .tasks(Collections.singletonList(Return.builder().id(TEST_FLOW_ID).type(Return.class.getName()).format(Property.ofValue(TEST_FLOW_ID)).build()))
                 .build();
             ;
@@ -571,21 +366,25 @@ public abstract class AbstractFlowRepositoryTest {
             deleteFlow(flow);
         }
 
-        Await.until(() -> FlowListener.getEmits().size() == 3, Duration.ofMillis(100), Duration.ofSeconds(5));
-        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.UPDATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        Await.until(() -> FlowListener.filterByTenant(tenant)
+            .size() == 3, Duration.ofMillis(100), Duration.ofSeconds(5));
+        assertThat(FlowListener.filterByTenant(tenant).stream()
+            .filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.filterByTenant(tenant).stream()
+            .filter(r -> r.getType() == CrudEventType.UPDATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.filterByTenant(tenant).stream()
+            .filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
-
     @Test
     void removeTriggerDelete() throws TimeoutException {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String flowId = IdUtils.create();
 
         Flow flow = Flow.builder()
             .id(flowId)
             .namespace(TEST_NAMESPACE)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .triggers(Collections.singletonList(UnitTest.builder()
                 .id("sleep")
                 .type(UnitTest.class.getName())
@@ -595,34 +394,39 @@ public abstract class AbstractFlowRepositoryTest {
 
         Flow save = flowRepository.create(GenericFlow.of(flow));
         try {
-            assertThat(flowRepository.findById(MAIN_TENANT, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
+            assertThat(flowRepository.findById(tenant, flow.getNamespace(), flow.getId()).isPresent()).isTrue();
         } finally {
             deleteFlow(save);
         }
 
-        Await.until(() -> FlowListener.getEmits().size() == 2, Duration.ofMillis(100), Duration.ofSeconds(5));
-        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        Await.until(() -> FlowListener.filterByTenant(tenant)
+            .size() == 2, Duration.ofMillis(100), Duration.ofSeconds(5));
+        assertThat(FlowListener.filterByTenant(tenant).stream()
+            .filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(FlowListener.filterByTenant(tenant).stream()
+            .filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
+
     @Test
     protected void shouldReturnNullRevisionForNonExistingFlow() {
-        assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, IdUtils.create())).isNull();
+        assertThat(flowRepository.lastRevision(TestsUtils.randomTenant(this.getClass().getSimpleName()), TEST_NAMESPACE, IdUtils.create())).isNull();
     }
 
     @Test
     protected void shouldReturnLastRevisionOnCreate() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // When
-            toDelete.add(flowRepository.create(createTestingLogFlow(flowId, "???")));
-            Integer result = flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId);
+            toDelete.add(flowRepository.create(createTestingLogFlow(tenant, flowId, "???")));
+            Integer result = flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId);
 
             // Then
             assertThat(result).isEqualTo(1);
-            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(1);
+            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(1);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -631,34 +435,36 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldIncrementRevisionOnDelete() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final String flowId = IdUtils.create();
-        FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
-        assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(1);
+        FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
+        assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(1);
 
         // When
         flowRepository.delete(created);
 
         // Then
-        assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(2);
+        assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(2);
     }
 
     @Test
     protected void shouldIncrementRevisionOnCreateAfterDelete() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
             flowRepository.delete(
-                flowRepository.create(createTestingLogFlow(flowId, "first"))
+                flowRepository.create(createTestingLogFlow(tenant, flowId, "first"))
             );
 
             // When
-            toDelete.add(flowRepository.create(createTestingLogFlow(flowId, "second")));
+            toDelete.add(flowRepository.create(createTestingLogFlow(tenant, flowId, "second")));
 
             // Then
-            assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
-            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(3);
+            assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
+            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(3);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -667,22 +473,23 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldReturnNullForLastRevisionAfterDelete() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
             toDelete.add(created);
 
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
             toDelete.add(updated);
 
             // When
             flowRepository.delete(updated);
 
             // Then
-            assertThat(flowRepository.findById(TEST_TENANT_ID, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
-            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isNull();
+            assertThat(flowRepository.findById(tenant, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
+            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isNull();
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -691,22 +498,23 @@ public abstract class AbstractFlowRepositoryTest {
     @Test
     protected void shouldFindAllRevisionsAfterDelete() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
             toDelete.add(created);
 
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
             toDelete.add(updated);
 
             // When
             flowRepository.delete(updated);
 
             // Then
-            assertThat(flowRepository.findById(TEST_TENANT_ID, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
-            assertThat(flowRepository.findRevisions(TEST_TENANT_ID, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
+            assertThat(flowRepository.findById(tenant, TEST_NAMESPACE, flowId, Optional.empty())).isEqualTo(Optional.empty());
+            assertThat(flowRepository.findRevisions(tenant, TEST_NAMESPACE, flowId).size()).isEqualTo(3);
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
@@ -714,21 +522,22 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     protected void shouldIncrementRevisionOnUpdateGivenNotEqualSource() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
 
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
             toDelete.add(created);
 
             // When
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "second"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "second"), created);
             toDelete.add(updated);
 
             // Then
             assertThat(updated.getRevision()).isEqualTo(2);
-            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(2);
+            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(2);
 
         } finally {
             toDelete.forEach(this::deleteFlow);
@@ -737,48 +546,39 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     protected void shouldNotIncrementRevisionOnUpdateGivenEqualSource() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         final List<Flow> toDelete = new ArrayList<>();
         final String flowId = IdUtils.create();
         try {
 
             // Given
-            FlowWithSource created = flowRepository.create(createTestingLogFlow(flowId, "first"));
+            FlowWithSource created = flowRepository.create(createTestingLogFlow(tenant, flowId, "first"));
             toDelete.add(created);
 
             // When
-            FlowWithSource updated = flowRepository.update(createTestingLogFlow(flowId, "first"), created);
+            FlowWithSource updated = flowRepository.update(createTestingLogFlow(tenant, flowId, "first"), created);
             toDelete.add(updated);
 
             // Then
             assertThat(updated.getRevision()).isEqualTo(1);
-            assertThat(flowRepository.lastRevision(TEST_TENANT_ID, TEST_NAMESPACE, flowId)).isEqualTo(1);
+            assertThat(flowRepository.lastRevision(tenant, TEST_NAMESPACE, flowId)).isEqualTo(1);
 
         } finally {
             toDelete.forEach(this::deleteFlow);
         }
     }
 
-    @Test
-    void shouldReturnForGivenQueryWildCardFilters() {
-        List<QueryFilter> filters = List.of(
-           QueryFilter.builder().field(QueryFilter.Field.QUERY).operation(QueryFilter.Op.EQUALS).value("*").build()
-        );
-        ArrayListTotal<Flow> flows = flowRepository.find(Pageable.from(1, 10), MAIN_TENANT, filters);
-        assertThat(flows.size()).isEqualTo(10);
-        assertThat(flows.getTotal()).isEqualTo(Helpers.FLOWS_COUNT);
-    }
-
     @Test
     void findByExecution() {
-        Flow flow = builder()
-            .tenantId(MAIN_TENANT)
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Flow flow = builder(tenant)
             .revision(1)
             .build();
         flowRepository.create(GenericFlow.of(flow));
         Execution execution = Execution.builder()
             .id(IdUtils.create())
             .namespace(flow.getNamespace())
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenant)
             .flowId(flow.getId())
             .flowRevision(flow.getRevision())
             .state(new State())
@@ -803,11 +603,13 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void findByExecutionNoRevision() {
-        Flow flow = builder()
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Flow flow = builder(tenant)
             .revision(3)
             .build();
         flowRepository.create(GenericFlow.of(flow));
         Execution execution = Execution.builder()
+            .tenantId(tenant)
             .id(IdUtils.create())
             .namespace(flow.getNamespace())
             .flowId(flow.getId())
@@ -833,16 +635,17 @@ public abstract class AbstractFlowRepositoryTest {
 
     @Test
     void shouldCountForNullTenant() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         FlowWithSource toDelete = null;
         try {
             // Given
-            Flow flow = createTestFlowForNamespace(TEST_NAMESPACE);
+            Flow flow = createTestFlowForNamespace(tenant, TEST_NAMESPACE);
             toDelete = flowRepository.create(GenericFlow.of(flow));
             // When
-            int count = flowRepository.count(MAIN_TENANT);
+            int count = flowRepository.count(tenant);
 
             // Then
-            Assertions.assertTrue(count > 0);
+            assertTrue(count > 0);
         } finally {
             Optional.ofNullable(toDelete).ifPresent(flow -> {
                 flowRepository.delete(flow);
@@ -850,11 +653,41 @@ public abstract class AbstractFlowRepositoryTest {
         }
     }
 
-    private static Flow createTestFlowForNamespace(String namespace) {
+    @Test
+    void should_exist_for_tenant(){
+        String tenantFlowExist = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flowExist = FlowWithSource.builder()
+            .id("flowExist")
+            .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
+            .tenantId(tenantFlowExist)
+            .deleted(false)
+            .build();
+        flowExist = flowRepository.create(GenericFlow.of(flowExist));
+
+        String tenantFlowDeleted = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        FlowWithSource flowDeleted = FlowWithSource.builder()
+            .id("flowDeleted")
+            .namespace(SYSTEM_FLOWS_DEFAULT_NAMESPACE)
+            .tenantId(tenantFlowDeleted)
+            .deleted(true)
+            .build();
+        flowDeleted = flowRepository.create(GenericFlow.of(flowDeleted));
+
+        try {
+            assertTrue(flowRepository.existAnyNoAcl(tenantFlowExist));
+            assertFalse(flowRepository.existAnyNoAcl("not_found"));
+            assertFalse(flowRepository.existAnyNoAcl(tenantFlowDeleted));
+        } finally {
+            deleteFlow(flowExist);
+            deleteFlow(flowDeleted);
+        }
+    }
+
+    private static Flow createTestFlowForNamespace(String tenantId, String namespace) {
         return Flow.builder()
             .id(IdUtils.create())
             .namespace(namespace)
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenantId)
             .tasks(List.of(Return.builder()
                 .id(IdUtils.create())
                 .type(Return.class.getName())
@@ -873,21 +706,31 @@ public abstract class AbstractFlowRepositoryTest {
     }
 
     @Singleton
-    public static class FlowListener implements ApplicationEventListener<CrudEvent<Flow>> {
-        @Getter
-        private static List<CrudEvent<Flow>> emits = new ArrayList<>();
+    public static class FlowListener implements ApplicationEventListener<CrudEvent<AbstractFlow>> {
+        private static List<CrudEvent<AbstractFlow>> emits = new CopyOnWriteArrayList<>();
 
         @Override
-        public void onApplicationEvent(CrudEvent<Flow> event) {
-            emits.add(event);
+        public void onApplicationEvent(CrudEvent<AbstractFlow> event) {
+            //This has to be done because Micronaut may send CrudEvent<Setting> for example, and we don't want them.
+            if ((event.getModel() != null && event.getModel() instanceof AbstractFlow)||
+                (event.getPreviousModel() != null && event.getPreviousModel() instanceof AbstractFlow)) {
+                emits.add(event);
+            }
         }
 
         public static void reset() {
-            emits = new ArrayList<>();
+            emits = new CopyOnWriteArrayList<>();
+        }
+
+        public static List<CrudEvent<AbstractFlow>> filterByTenant(String tenantId){
+            return emits.stream()
+                .filter(e -> (e.getPreviousModel() != null && e.getPreviousModel().getTenantId().equals(tenantId)) ||
+                    (e.getModel() != null && e.getModel().getTenantId().equals(tenantId)))
+                .toList();
         }
     }
 
-    private static GenericFlow createTestingLogFlow(String id, String logMessage) {
+    private static GenericFlow createTestingLogFlow(String tenantId, String id, String logMessage) {
         String source = """
                id: %s
                namespace: %s
@@ -896,7 +739,7 @@ public abstract class AbstractFlowRepositoryTest {
                    type: io.kestra.plugin.core.log.Log
                    message: %s
             """.formatted(id, TEST_NAMESPACE, logMessage);
-        return GenericFlow.fromYaml(TEST_TENANT_ID, source);
+        return GenericFlow.fromYaml(tenantId, source);
     }
 
     protected static int COUNTER = 0;

core/src/test/java/io/kestra/core/repositories/AbstractFlowTopologyRepositoryTest.java

@@ -4,7 +4,7 @@ import io.kestra.core.models.topologies.FlowNode;
 import io.kestra.core.models.topologies.FlowRelation;
 import io.kestra.core.models.topologies.FlowTopology;
 import io.kestra.core.junit.annotations.KestraTest;
-import io.kestra.core.tenant.TenantService;
+import io.kestra.core.utils.TestsUtils;
 import jakarta.inject.Inject;
 import org.junit.jupiter.api.Test;
 
@@ -17,21 +17,21 @@ public abstract class AbstractFlowTopologyRepositoryTest {
     @Inject
     private FlowTopologyRepositoryInterface flowTopologyRepository;
 
-    protected FlowTopology createSimpleFlowTopology(String flowA, String flowB, String namespace) {
+    protected FlowTopology createSimpleFlowTopology(String tenantId, String flowA, String flowB, String namespace) {
         return FlowTopology.builder()
             .relation(FlowRelation.FLOW_TASK)
             .source(FlowNode.builder()
                 .id(flowA)
                 .namespace(namespace)
-                .tenantId(TenantService.MAIN_TENANT)
-                .uid(flowA)
+                .tenantId(tenantId)
+                .uid(tenantId + flowA)
                 .build()
             )
             .destination(FlowNode.builder()
                 .id(flowB)
                 .namespace(namespace)
-                .tenantId(TenantService.MAIN_TENANT)
-                .uid(flowB)
+                .tenantId(tenantId)
+                .uid(tenantId + flowB)
                 .build()
             )
             .build();
@@ -39,42 +39,45 @@ public abstract class AbstractFlowTopologyRepositoryTest {
 
     @Test
     void findByFlow() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findByFlow(TenantService.MAIN_TENANT, "io.kestra.tests", "flow-a", false);
+        List<FlowTopology> list = flowTopologyRepository.findByFlow(tenant, "io.kestra.tests", "flow-a", false);
 
         assertThat(list.size()).isEqualTo(1);
     }
 
     @Test
     void findByNamespace() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-c", "flow-d", "io.kestra.tests")
+            createSimpleFlowTopology(tenant, "flow-c", "flow-d", "io.kestra.tests")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findByNamespace(TenantService.MAIN_TENANT, "io.kestra.tests");
+        List<FlowTopology> list = flowTopologyRepository.findByNamespace(tenant, "io.kestra.tests");
 
         assertThat(list.size()).isEqualTo(2);
     }
 
     @Test
     void findAll() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-a", "flow-b", "io.kestra.tests")
+            createSimpleFlowTopology(tenant, "flow-a", "flow-b", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-c", "flow-d", "io.kestra.tests")
+            createSimpleFlowTopology(tenant, "flow-c", "flow-d", "io.kestra.tests")
         );
         flowTopologyRepository.save(
-            createSimpleFlowTopology("flow-e", "flow-f", "io.kestra.tests.2")
+            createSimpleFlowTopology(tenant, "flow-e", "flow-f", "io.kestra.tests.2")
         );
 
-        List<FlowTopology> list = flowTopologyRepository.findAll(TenantService.MAIN_TENANT);
+        List<FlowTopology> list = flowTopologyRepository.findAll(tenant);
 
         assertThat(list.size()).isEqualTo(3);
     }

core/src/test/java/io/kestra/core/repositories/AbstractLogRepositoryTest.java

@@ -34,9 +34,7 @@ import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.SYSTEM;
 import static io.kestra.core.models.flows.FlowScope.USER;
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatReflectiveOperationException;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @KestraTest
@@ -44,11 +42,11 @@ public abstract class AbstractLogRepositoryTest {
     @Inject
     protected LogRepositoryInterface logRepository;
 
-    protected static LogEntry.LogEntryBuilder logEntry(Level level) {
-        return logEntry(level, IdUtils.create());
+    protected static LogEntry.LogEntryBuilder logEntry(String tenantId, Level level) {
+        return logEntry(tenantId, level, IdUtils.create());
     }
 
-    protected static LogEntry.LogEntryBuilder logEntry(Level level, String executionId) {
+    protected static LogEntry.LogEntryBuilder logEntry(String tenantId, Level level, String executionId) {
         return LogEntry.builder()
             .flowId("flowId")
             .namespace("io.kestra.unittest")
@@ -59,7 +57,7 @@ public abstract class AbstractLogRepositoryTest {
             .timestamp(Instant.now())
             .level(level)
             .thread("")
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenantId)
             .triggerId("triggerId")
             .message("john doe");
     }
@@ -67,9 +65,10 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-        logRepository.save(logEntry(Level.INFO, "executionId").build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
 
-        ArrayListTotal<LogEntry> entries = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
+        ArrayListTotal<LogEntry> entries = logRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
 
         assertThat(entries).hasSize(1);
     }
@@ -77,9 +76,10 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_async(QueryFilter filter){
-        logRepository.save(logEntry(Level.INFO, "executionId").build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
 
-        Flux<LogEntry> find = logRepository.findAsync(MAIN_TENANT, List.of(filter));
+        Flux<LogEntry> find = logRepository.findAsync(tenant, List.of(filter));
 
         List<LogEntry> logEntries = find.collectList().block();
         assertThat(logEntries).hasSize(1);
@@ -88,11 +88,12 @@ public abstract class AbstractLogRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_delete_with_filter(QueryFilter filter){
-        logRepository.save(logEntry(Level.INFO, "executionId").build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO, "executionId").build());
 
-        logRepository.deleteByFilters(MAIN_TENANT, List.of(filter));
+        logRepository.deleteByFilters(tenant, List.of(filter));
 
-        assertThat(logRepository.findAllAsync(MAIN_TENANT).collectList().block()).isEmpty();
+        assertThat(logRepository.findAllAsync(tenant).collectList().block()).isEmpty();
     }
 
 
@@ -152,7 +153,10 @@ public abstract class AbstractLogRepositoryTest {
     void should_fail_to_find_all(QueryFilter filter){
         assertThrows(
             InvalidQueryFiltersException.class,
-            () -> logRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
+            () -> logRepository.find(
+                Pageable.UNPAGED,
+                TestsUtils.randomTenant(this.getClass().getSimpleName()),
+                List.of(filter)));
 
     }
 
@@ -170,16 +174,17 @@ public abstract class AbstractLogRepositoryTest {
 
     @Test
     void all() {
-        LogEntry.LogEntryBuilder builder = logEntry(Level.INFO);
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        LogEntry.LogEntryBuilder builder = logEntry(tenant, Level.INFO);
 
-        ArrayListTotal<LogEntry> find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
+        ArrayListTotal<LogEntry> find = logRepository.find(Pageable.UNPAGED, tenant, null);
         assertThat(find.size()).isZero();
 
 
         LogEntry save = logRepository.save(builder.build());
         logRepository.save(builder.executionKind(ExecutionKind.TEST).build()); // should only be loaded by execution id
 
-        find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
+        find = logRepository.find(Pageable.UNPAGED, tenant, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
         var filters = List.of(QueryFilter.builder()
@@ -195,7 +200,7 @@ public abstract class AbstractLogRepositoryTest {
         find = logRepository.find(Pageable.UNPAGED,  "doe", filters);
         assertThat(find.size()).isZero();
 
-        find = logRepository.find(Pageable.UNPAGED, MAIN_TENANT, null);
+        find = logRepository.find(Pageable.UNPAGED, tenant, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
@@ -203,141 +208,146 @@ public abstract class AbstractLogRepositoryTest {
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        List<LogEntry> list = logRepository.findByExecutionId(MAIN_TENANT, save.getExecutionId(), null);
+        List<LogEntry> list = logRepository.findByExecutionId(tenant, save.getExecutionId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionId(MAIN_TENANT, "io.kestra.unittest", "flowId", save.getExecutionId(), null);
+        list = logRepository.findByExecutionId(tenant, "io.kestra.unittest", "flowId", save.getExecutionId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(tenant, save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, "io.kestra.unittest", "flowId", save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(tenant, "io.kestra.unittest", "flowId", save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, save.getExecutionId(), save.getTaskRunId(), null);
+        list = logRepository.findByExecutionIdAndTaskRunId(tenant, save.getExecutionId(), save.getTaskRunId(), null);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
-        list = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(MAIN_TENANT, save.getExecutionId(), save.getTaskRunId(), null, 0);
+        list = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(tenant, save.getExecutionId(), save.getTaskRunId(), null, 0);
         assertThat(list.size()).isEqualTo(2);
         assertThat(list.getFirst().getExecutionId()).isEqualTo(save.getExecutionId());
 
         Integer countDeleted = logRepository.purge(Execution.builder().id(save.getExecutionId()).build());
         assertThat(countDeleted).isEqualTo(2);
 
-        list = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, save.getExecutionId(), save.getTaskId(), null);
+        list = logRepository.findByExecutionIdAndTaskId(tenant, save.getExecutionId(), save.getTaskId(), null);
         assertThat(list.size()).isZero();
     }
 
     @Test
     void pageable() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = "123";
-        LogEntry.LogEntryBuilder builder = logEntry(Level.INFO);
+        LogEntry.LogEntryBuilder builder = logEntry(tenant, Level.INFO);
         builder.executionId(executionId);
 
         for (int i = 0; i < 80; i++) {
             logRepository.save(builder.build());
         }
 
-        builder = logEntry(Level.INFO).executionId(executionId).taskId("taskId2").taskRunId("taskRunId2");
+        builder = logEntry(tenant, Level.INFO).executionId(executionId).taskId("taskId2").taskRunId("taskRunId2");
         LogEntry logEntry2 = logRepository.save(builder.build());
         for (int i = 0; i < 20; i++) {
             logRepository.save(builder.build());
         }
 
-        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(MAIN_TENANT, executionId, null, Pageable.from(1, 50));
+        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(tenant, executionId, null, Pageable.from(1, 50));
 
         assertThat(find.size()).isEqualTo(50);
         assertThat(find.getTotal()).isEqualTo(101L);
 
-        find = logRepository.findByExecutionId(MAIN_TENANT, executionId, null, Pageable.from(3, 50));
+        find = logRepository.findByExecutionId(tenant, executionId, null, Pageable.from(3, 50));
 
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getTotal()).isEqualTo(101L);
 
-        find = logRepository.findByExecutionIdAndTaskId(MAIN_TENANT, executionId, logEntry2.getTaskId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionIdAndTaskId(tenant, executionId, logEntry2.getTaskId(), null, Pageable.from(1, 50));
 
         assertThat(find.size()).isEqualTo(21);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, Pageable.from(1, 10));
+        find = logRepository.findByExecutionIdAndTaskRunId(tenant, executionId, logEntry2.getTaskRunId(), null, Pageable.from(1, 10));
 
         assertThat(find.size()).isEqualTo(10);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, 0, Pageable.from(1, 10));
+        find = logRepository.findByExecutionIdAndTaskRunIdAndAttempt(tenant, executionId, logEntry2.getTaskRunId(), null, 0, Pageable.from(1, 10));
 
         assertThat(find.size()).isEqualTo(10);
         assertThat(find.getTotal()).isEqualTo(21L);
 
-        find = logRepository.findByExecutionIdAndTaskRunId(MAIN_TENANT, executionId, logEntry2.getTaskRunId(), null, Pageable.from(10, 10));
+        find = logRepository.findByExecutionIdAndTaskRunId(tenant, executionId, logEntry2.getTaskRunId(), null, Pageable.from(10, 10));
 
         assertThat(find.size()).isZero();
     }
 
     @Test
     void shouldFindByExecutionIdTestLogs() {
-        var builder = logEntry(Level.INFO).executionId("123").executionKind(ExecutionKind.TEST).build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        var builder = logEntry(tenant, Level.INFO).executionId("123").executionKind(ExecutionKind.TEST).build();
         logRepository.save(builder);
 
-        List<LogEntry> logs = logRepository.findByExecutionId(MAIN_TENANT, builder.getExecutionId(), null);
+        List<LogEntry> logs = logRepository.findByExecutionId(tenant, builder.getExecutionId(), null);
         assertThat(logs).hasSize(1);
     }
 
     @Test
     void deleteByQuery() {
-        LogEntry log1 = logEntry(Level.INFO).build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        LogEntry log1 = logEntry(tenant, Level.INFO).build();
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(MAIN_TENANT, log1.getExecutionId(), null, null, null, null);
+        logRepository.deleteByQuery(tenant, log1.getExecutionId(), null, null, null, null);
 
-        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
+        ArrayListTotal<LogEntry> find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(MAIN_TENANT, "io.kestra.unittest", "flowId", null, List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
+        logRepository.deleteByQuery(tenant, "io.kestra.unittest", "flowId", null, List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
 
-        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(MAIN_TENANT, "io.kestra.unittest", "flowId", null);
+        logRepository.deleteByQuery(tenant, "io.kestra.unittest", "flowId", null);
 
-        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
 
         logRepository.save(log1);
 
-        logRepository.deleteByQuery(MAIN_TENANT, null, null, log1.getExecutionId(), List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
+        logRepository.deleteByQuery(tenant, null, null, log1.getExecutionId(), List.of(Level.TRACE, Level.DEBUG, Level.INFO), null, ZonedDateTime.now().plusMinutes(1));
 
-        find = logRepository.findByExecutionId(MAIN_TENANT, log1.getExecutionId(), null, Pageable.from(1, 50));
+        find = logRepository.findByExecutionId(tenant, log1.getExecutionId(), null, Pageable.from(1, 50));
         assertThat(find.size()).isZero();
     }
 
     @Test
     void findAllAsync() {
-        logRepository.save(logEntry(Level.INFO).build());
-        logRepository.save(logEntry(Level.INFO).executionKind(ExecutionKind.TEST).build()); // should be present as it's used for backup
-        logRepository.save(logEntry(Level.ERROR).build());
-        logRepository.save(logEntry(Level.WARN).build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO).build());
+        logRepository.save(logEntry(tenant, Level.INFO).executionKind(ExecutionKind.TEST).build()); // should be present as it's used for backup
+        logRepository.save(logEntry(tenant, Level.ERROR).build());
+        logRepository.save(logEntry(tenant, Level.WARN).build());
 
-        Flux<LogEntry> find = logRepository.findAllAsync(MAIN_TENANT);
+        Flux<LogEntry> find = logRepository.findAllAsync(tenant);
         List<LogEntry> logEntries = find.collectList().block();
         assertThat(logEntries).hasSize(4);
     }
 
     @Test
     void fetchData() throws IOException {
-        logRepository.save(logEntry(Level.INFO).build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO).build());
 
-        var results = logRepository.fetchData(MAIN_TENANT,
+        var results = logRepository.fetchData(tenant,
             Logs.builder()
                 .type(Logs.class.getName())
                 .columns(Map.of(
@@ -353,10 +363,11 @@ public abstract class AbstractLogRepositoryTest {
 
     @Test
     void purge() {
-        logRepository.save(logEntry(Level.INFO, "execution1").build());
-        logRepository.save(logEntry(Level.INFO, "execution1").build());
-        logRepository.save(logEntry(Level.INFO, "execution2").build());
-        logRepository.save(logEntry(Level.INFO, "execution2").build());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        logRepository.save(logEntry(tenant, Level.INFO, "execution1").build());
+        logRepository.save(logEntry(tenant, Level.INFO, "execution1").build());
+        logRepository.save(logEntry(tenant, Level.INFO, "execution2").build());
+        logRepository.save(logEntry(tenant, Level.INFO, "execution2").build());
 
         var result = logRepository.purge(List.of(Execution.builder().id("execution1").build(), Execution.builder().id("execution2").build()));
         assertThat(result).isEqualTo(4);

core/src/test/java/io/kestra/core/repositories/AbstractMetricRepositoryTest.java

@@ -8,6 +8,7 @@ import io.kestra.core.models.executions.TaskRun;
 import io.kestra.core.models.executions.metrics.Counter;
 import io.kestra.core.models.executions.metrics.MetricAggregations;
 import io.kestra.core.models.executions.metrics.Timer;
+import io.kestra.core.utils.TestsUtils;
 import io.micronaut.data.model.Pageable;
 import io.kestra.core.junit.annotations.KestraTest;
 import jakarta.inject.Inject;
@@ -27,27 +28,28 @@ public abstract class AbstractMetricRepositoryTest {
 
     @Test
     void all() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = FriendlyId.createFriendlyId();
-        TaskRun taskRun1 = taskRun(executionId, "task");
+        TaskRun taskRun1 = taskRun(tenant, executionId, "task");
         MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
         MetricEntry testCounter = MetricEntry.of(taskRun1, counter("test"), ExecutionKind.TEST);
-        TaskRun taskRun2 = taskRun(executionId, "task");
+        TaskRun taskRun2 = taskRun(tenant, executionId, "task");
         MetricEntry timer = MetricEntry.of(taskRun2, timer(), null);
         metricRepository.save(counter);
         metricRepository.save(testCounter); // should only be retrieved by execution id
         metricRepository.save(timer);
 
-        List<MetricEntry> results = metricRepository.findByExecutionId(null, executionId, Pageable.from(1, 10));
+        List<MetricEntry> results = metricRepository.findByExecutionId(tenant, executionId, Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(3);
 
-        results = metricRepository.findByExecutionIdAndTaskId(null, executionId, taskRun1.getTaskId(), Pageable.from(1, 10));
+        results = metricRepository.findByExecutionIdAndTaskId(tenant, executionId, taskRun1.getTaskId(), Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(3);
 
-        results = metricRepository.findByExecutionIdAndTaskRunId(null, executionId, taskRun1.getId(), Pageable.from(1, 10));
+        results = metricRepository.findByExecutionIdAndTaskRunId(tenant, executionId, taskRun1.getId(), Pageable.from(1, 10));
         assertThat(results.size()).isEqualTo(2);
 
         MetricAggregations aggregationResults = metricRepository.aggregateByFlowId(
-            null,
+            tenant,
             "namespace",
             "flow",
             null,
@@ -61,7 +63,7 @@ public abstract class AbstractMetricRepositoryTest {
         assertThat(aggregationResults.getGroupBy()).isEqualTo("day");
 
         aggregationResults = metricRepository.aggregateByFlowId(
-            null,
+            tenant,
             "namespace",
             "flow",
             null,
@@ -78,11 +80,12 @@ public abstract class AbstractMetricRepositoryTest {
 
      @Test
      void names() {
+         String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
          String executionId = FriendlyId.createFriendlyId();
-         TaskRun taskRun1 = taskRun(executionId, "task");
+         TaskRun taskRun1 = taskRun(tenant, executionId, "task");
          MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
 
-         TaskRun taskRun2 = taskRun(executionId, "task2");
+         TaskRun taskRun2 = taskRun(tenant, executionId, "task2");
          MetricEntry counter2 = MetricEntry.of(taskRun2, counter("counter2"), null);
 
          MetricEntry test = MetricEntry.of(taskRun2, counter("test"), ExecutionKind.TEST);
@@ -92,9 +95,9 @@ public abstract class AbstractMetricRepositoryTest {
          metricRepository.save(test); // should only be retrieved by execution id
 
 
-         List<String> flowMetricsNames = metricRepository.flowMetrics(null, "namespace", "flow");
-         List<String> taskMetricsNames = metricRepository.taskMetrics(null, "namespace", "flow", "task");
-         List<String> tasksWithMetrics = metricRepository.tasksWithMetrics(null, "namespace", "flow");
+         List<String> flowMetricsNames = metricRepository.flowMetrics(tenant, "namespace", "flow");
+         List<String> taskMetricsNames = metricRepository.taskMetrics(tenant, "namespace", "flow", "task");
+         List<String> tasksWithMetrics = metricRepository.tasksWithMetrics(tenant, "namespace", "flow");
 
          assertThat(flowMetricsNames.size()).isEqualTo(2);
          assertThat(taskMetricsNames.size()).isEqualTo(1);
@@ -103,26 +106,28 @@ public abstract class AbstractMetricRepositoryTest {
 
     @Test
     void findAllAsync() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         String executionId = FriendlyId.createFriendlyId();
-        TaskRun taskRun1 = taskRun(executionId, "task");
+        TaskRun taskRun1 = taskRun(tenant, executionId, "task");
         MetricEntry counter = MetricEntry.of(taskRun1, counter("counter"), null);
-        TaskRun taskRun2 = taskRun(executionId, "task");
+        TaskRun taskRun2 = taskRun(tenant, executionId, "task");
         MetricEntry timer = MetricEntry.of(taskRun2, timer(), null);
         MetricEntry test = MetricEntry.of(taskRun2, counter("test"), ExecutionKind.TEST);
         metricRepository.save(counter);
         metricRepository.save(timer);
         metricRepository.save(test); // should be retrieved as findAllAsync is used for backup
 
-        List<MetricEntry> results = metricRepository.findAllAsync(null).collectList().block();
+        List<MetricEntry> results = metricRepository.findAllAsync(tenant).collectList().block();
         assertThat(results).hasSize(3);
     }
 
     @Test
     void purge() {
-        metricRepository.save(MetricEntry.of(taskRun("execution1", "task"), counter("counter1"), null));
-        metricRepository.save(MetricEntry.of(taskRun("execution1", "task"), counter("counter2"), null));
-        metricRepository.save(MetricEntry.of(taskRun("execution2", "task"), counter("counter1"), null));
-        metricRepository.save(MetricEntry.of(taskRun("execution2", "task"), counter("counter2"), null));
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        metricRepository.save(MetricEntry.of(taskRun(tenant, "execution1", "task"), counter("counter1"), null));
+        metricRepository.save(MetricEntry.of(taskRun(tenant, "execution1", "task"), counter("counter2"), null));
+        metricRepository.save(MetricEntry.of(taskRun(tenant, "execution2", "task"), counter("counter1"), null));
+        metricRepository.save(MetricEntry.of(taskRun(tenant, "execution2", "task"), counter("counter2"), null));
 
         var result = metricRepository.purge(List.of(Execution.builder().id("execution1").build(), Execution.builder().id("execution2").build()));
         assertThat(result).isEqualTo(4);
@@ -136,8 +141,9 @@ public abstract class AbstractMetricRepositoryTest {
         return Timer.of("counter", Duration.ofSeconds(5));
     }
 
-    private TaskRun taskRun(String executionId, String taskId) {
+    private TaskRun taskRun(String tenantId, String executionId, String taskId) {
         return TaskRun.builder()
+            .tenantId(tenantId)
             .flowId("flow")
             .namespace("namespace")
             .executionId(executionId)

core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java

@@ -4,6 +4,8 @@ import io.kestra.core.events.CrudEvent;
 import io.kestra.core.events.CrudEventType;
 import io.kestra.core.models.property.Property;
 import io.kestra.core.models.templates.Template;
+import io.kestra.core.utils.Await;
+import io.kestra.core.utils.TestsUtils;
 import io.kestra.plugin.core.debug.Return;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.context.event.ApplicationEventListener;
@@ -11,7 +13,10 @@ import io.micronaut.data.model.Pageable;
 import io.kestra.core.junit.annotations.KestraTest;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
-import org.junit.jupiter.api.BeforeEach;
+import java.time.Duration;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.TimeoutException;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
@@ -20,6 +25,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -28,55 +35,60 @@ public abstract class AbstractTemplateRepositoryTest {
     @Inject
     protected TemplateRepositoryInterface templateRepository;
 
-    @BeforeEach
-    protected void init() throws IOException, URISyntaxException {
+    @BeforeAll
+    protected static void init() throws IOException, URISyntaxException {
         TemplateListener.reset();
     }
 
-    protected static Template.TemplateBuilder<?, ?> builder() {
-        return builder(null);
+    protected static Template.TemplateBuilder<?, ?> builder(String tenantId) {
+        return builder(tenantId, null);
     }
 
-    protected static Template.TemplateBuilder<?, ?> builder(String namespace) {
+    protected static Template.TemplateBuilder<?, ?> builder(String tenantId, String namespace) {
         return Template.builder()
             .id(IdUtils.create())
             .namespace(namespace == null ? "kestra.test" : namespace)
+            .tenantId(tenantId)
             .tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format(Property.ofValue("test")).build()));
     }
 
     @Test
     void findById() {
-        Template template = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Template template = builder(tenant).build();
         templateRepository.create(template);
 
-        Optional<Template> full = templateRepository.findById(null, template.getNamespace(), template.getId());
+        Optional<Template> full = templateRepository.findById(tenant, template.getNamespace(), template.getId());
         assertThat(full.isPresent()).isTrue();
         assertThat(full.get().getId()).isEqualTo(template.getId());
 
-        full = templateRepository.findById(null, template.getNamespace(), template.getId());
+        full = templateRepository.findById(tenant, template.getNamespace(), template.getId());
         assertThat(full.isPresent()).isTrue();
         assertThat(full.get().getId()).isEqualTo(template.getId());
     }
 
     @Test
     void findByNamespace() {
-        Template template1 = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Template template1 = builder(tenant).build();
         Template template2 = Template.builder()
             .id(IdUtils.create())
+            .tenantId(tenant)
             .namespace("kestra.test.template").build();
 
         templateRepository.create(template1);
         templateRepository.create(template2);
 
-        List<Template> templates = templateRepository.findByNamespace(null, template1.getNamespace());
+        List<Template> templates = templateRepository.findByNamespace(tenant, template1.getNamespace());
         assertThat(templates.size()).isGreaterThanOrEqualTo(1);
-        templates = templateRepository.findByNamespace(null, template2.getNamespace());
+        templates = templateRepository.findByNamespace(tenant, template2.getNamespace());
         assertThat(templates.size()).isEqualTo(1);
     }
 
     @Test
     void save() {
-        Template template = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Template template = builder(tenant).build();
         Template save = templateRepository.create(template);
 
         assertThat(save.getId()).isEqualTo(template.getId());
@@ -84,41 +96,42 @@ public abstract class AbstractTemplateRepositoryTest {
 
     @Test
     void findAll() {
-        long saveCount = templateRepository.findAll(null).size();
-        Template template = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        long saveCount = templateRepository.findAll(tenant).size();
+        Template template = builder(tenant).build();
         templateRepository.create(template);
-        long size = templateRepository.findAll(null).size();
+        long size = templateRepository.findAll(tenant).size();
         assertThat(size).isGreaterThan(saveCount);
         templateRepository.delete(template);
-        assertThat((long) templateRepository.findAll(null).size()).isEqualTo(saveCount);
+        assertThat((long) templateRepository.findAll(tenant).size()).isEqualTo(saveCount);
     }
 
     @Test
     void findAllForAllTenants() {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         long saveCount = templateRepository.findAllForAllTenants().size();
-        Template template = builder().build();
+        Template template = builder(tenant).build();
         templateRepository.create(template);
         long size = templateRepository.findAllForAllTenants().size();
         assertThat(size).isGreaterThan(saveCount);
-        templateRepository.delete(template);
-        assertThat((long) templateRepository.findAllForAllTenants().size()).isEqualTo(saveCount);
     }
 
     @Test
     void find() {
-        Template template1 = builder().build();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Template template1 = builder(tenant).build();
         templateRepository.create(template1);
-        Template template2 = builder().build();
+        Template template2 = builder(tenant).build();
         templateRepository.create(template2);
-        Template template3 = builder().build();
+        Template template3 = builder(tenant).build();
         templateRepository.create(template3);
 
         // with pageable
-        List<Template> save = templateRepository.find(Pageable.from(1, 10),null, null, "kestra.test");
+        List<Template> save = templateRepository.find(Pageable.from(1, 10),null, tenant, "kestra.test");
         assertThat((long) save.size()).isGreaterThanOrEqualTo(3L);
 
         // without pageable
-        save = templateRepository.find(null, null, "kestra.test");
+        save = templateRepository.find(null, tenant, "kestra.test");
         assertThat((long) save.size()).isGreaterThanOrEqualTo(3L);
 
         templateRepository.delete(template1);
@@ -126,31 +139,45 @@ public abstract class AbstractTemplateRepositoryTest {
         templateRepository.delete(template3);
     }
 
+    private static final Logger LOG = LoggerFactory.getLogger(AbstractTemplateRepositoryTest.class);
+
     @Test
-    void delete() {
-        Template template = builder().build();
+    protected void delete() throws TimeoutException {
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Template template = builder(tenant).build();
 
         Template save = templateRepository.create(template);
         templateRepository.delete(save);
 
-        assertThat(templateRepository.findById(null, template.getNamespace(), template.getId()).isPresent()).isFalse();
+        assertThat(templateRepository.findById(tenant, template.getNamespace(), template.getId()).isPresent()).isFalse();
 
-        assertThat(TemplateListener.getEmits().size()).isEqualTo(2);
-        assertThat(TemplateListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
-        assertThat(TemplateListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
+        Await.until(() -> {
+            LOG.info("-------------> number of event: {}", TemplateListener.getEmits(tenant).size());
+            return TemplateListener.getEmits(tenant).size() == 2;
+
+        }, Duration.ofMillis(100), Duration.ofSeconds(5));
+        assertThat(TemplateListener.getEmits(tenant).stream().filter(r -> r.getType() == CrudEventType.CREATE).count()).isEqualTo(1L);
+        assertThat(TemplateListener.getEmits(tenant).stream().filter(r -> r.getType() == CrudEventType.DELETE).count()).isEqualTo(1L);
     }
 
     @Singleton
     public static class TemplateListener implements ApplicationEventListener<CrudEvent<Template>> {
-        private static List<CrudEvent<Template>> emits = new ArrayList<>();
+        private static List<CrudEvent<Template>> emits = new CopyOnWriteArrayList<>();
 
         @Override
         public void onApplicationEvent(CrudEvent<Template> event) {
-            emits.add(event);
+            //The instanceOf is required because Micronaut may send non Template event via this method
+            if ((event.getModel() != null && event.getModel() instanceof Template) ||
+                    (event.getPreviousModel() != null && event.getPreviousModel() instanceof Template)) {
+                emits.add(event);
+            }
         }
 
-        public static List<CrudEvent<Template>> getEmits() {
-            return emits;
+        public static List<CrudEvent<Template>> getEmits(String tenantId){
+            return emits.stream()
+                .filter(e -> (e.getModel() != null && e.getModel().getTenantId().equals(tenantId)) ||
+                    (e.getPreviousModel() != null && e.getPreviousModel().getTenantId().equals(tenantId)))
+                .toList();
         }
 
         public static void reset() {

core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java

@@ -9,6 +9,7 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.models.triggers.Trigger;
 import io.kestra.core.repositories.ExecutionRepositoryInterface.ChildFilter;
 import io.kestra.core.utils.IdUtils;
+import io.kestra.core.utils.TestsUtils;
 import io.micronaut.data.model.Pageable;
 import io.micronaut.data.model.Sort;
 import jakarta.inject.Inject;
@@ -24,7 +25,6 @@ import java.util.Optional;
 import java.util.stream.Stream;
 
 import static io.kestra.core.models.flows.FlowScope.USER;
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
@@ -35,8 +35,9 @@ public abstract class AbstractTriggerRepositoryTest {
     @Inject
     protected TriggerRepositoryInterface triggerRepository;
 
-    private static Trigger.TriggerBuilder<?, ?> trigger() {
+    private static Trigger.TriggerBuilder<?, ?> trigger(String tenantId) {
         return Trigger.builder()
+            .tenantId(tenantId)
             .flowId(IdUtils.create())
             .namespace(TEST_NAMESPACE)
             .triggerId(IdUtils.create())
@@ -44,9 +45,9 @@ public abstract class AbstractTriggerRepositoryTest {
             .date(ZonedDateTime.now());
     }
 
-    protected static Trigger generateDefaultTrigger(){
+    protected static Trigger generateDefaultTrigger(String tenantId){
         Trigger trigger = Trigger.builder()
-            .tenantId(MAIN_TENANT)
+            .tenantId(tenantId)
             .triggerId("triggerId")
             .namespace("trigger.namespace")
             .flowId("flowId")
@@ -59,9 +60,10 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all(QueryFilter filter){
-        triggerRepository.save(generateDefaultTrigger());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        triggerRepository.save(generateDefaultTrigger(tenant));
 
-        ArrayListTotal<Trigger> entries = triggerRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter));
+        ArrayListTotal<Trigger> entries = triggerRepository.find(Pageable.UNPAGED, tenant, List.of(filter));
 
         assertThat(entries).hasSize(1);
     }
@@ -69,9 +71,10 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("filterCombinations")
     void should_find_all_async(QueryFilter filter){
-        triggerRepository.save(generateDefaultTrigger());
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        triggerRepository.save(generateDefaultTrigger(tenant));
 
-        List<Trigger> entries = triggerRepository.find(MAIN_TENANT, List.of(filter)).collectList().block();
+        List<Trigger> entries = triggerRepository.find(tenant, List.of(filter)).collectList().block();
 
         assertThat(entries).hasSize(1);
     }
@@ -92,7 +95,7 @@ public abstract class AbstractTriggerRepositoryTest {
     @ParameterizedTest
     @MethodSource("errorFilterCombinations")
     void should_fail_to_find_all(QueryFilter filter){
-        assertThrows(InvalidQueryFiltersException.class, () -> triggerRepository.find(Pageable.UNPAGED, MAIN_TENANT, List.of(filter)));
+        assertThrows(InvalidQueryFiltersException.class, () -> triggerRepository.find(Pageable.UNPAGED, TestsUtils.randomTenant(this.getClass().getSimpleName()), List.of(filter)));
     }
 
     static Stream<QueryFilter> errorFilterCombinations() {
@@ -110,7 +113,8 @@ public abstract class AbstractTriggerRepositoryTest {
 
     @Test
     void all() {
-        Trigger.TriggerBuilder<?, ?> builder = trigger();
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
+        Trigger.TriggerBuilder<?, ?> builder = trigger(tenant);
 
         Optional<Trigger> findLast = triggerRepository.findLast(builder.build());
         assertThat(findLast.isPresent()).isFalse();
@@ -130,47 +134,47 @@ public abstract class AbstractTriggerRepositoryTest {
         assertThat(findLast.get().getExecutionId()).isEqualTo(save.getExecutionId());
 
 
-        triggerRepository.save(trigger().build());
-        triggerRepository.save(trigger().build());
-        Trigger searchedTrigger = trigger().build();
+        triggerRepository.save(trigger(tenant).build());
+        triggerRepository.save(trigger(tenant).build());
+        Trigger searchedTrigger = trigger(tenant).build();
         triggerRepository.save(searchedTrigger);
 
         List<Trigger> all = triggerRepository.findAllForAllTenants();
 
-        assertThat(all.size()).isEqualTo(4);
+        assertThat(all.size()).isGreaterThanOrEqualTo(4);
 
-        all = triggerRepository.findAll(null);
+        all = triggerRepository.findAll(tenant);
 
         assertThat(all.size()).isEqualTo(4);
 
         String namespacePrefix = "io.kestra.another";
         String namespace = namespacePrefix + ".ns";
-        Trigger trigger = trigger().namespace(namespace).build();
+        Trigger trigger = trigger(tenant).namespace(namespace).build();
         triggerRepository.save(trigger);
 
-        List<Trigger> find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, null, null, null, null);
+        List<Trigger> find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, tenant, null, null, null);
         assertThat(find.size()).isEqualTo(4);
         assertThat(find.getFirst().getNamespace()).isEqualTo(namespace);
 
-        find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, null, null, searchedTrigger.getFlowId(), null);
+        find = triggerRepository.find(Pageable.from(1, 4, Sort.of(Sort.Order.asc("namespace"))), null, tenant, null, searchedTrigger.getFlowId(), null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getFlowId()).isEqualTo(searchedTrigger.getFlowId());
 
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.of(Sort.Order.asc(triggerRepository.sortMapping().apply("triggerId")))), null, null, namespacePrefix, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.of(Sort.Order.asc(triggerRepository.sortMapping().apply("triggerId")))), null, tenant, namespacePrefix, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(trigger.getTriggerId());
 
         // Full text search is on namespace, flowId, triggerId, executionId
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), trigger.getNamespace(), null, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), trigger.getNamespace(), tenant, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(trigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getFlowId(), null, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getFlowId(), tenant, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getTriggerId(), null, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getTriggerId(), tenant, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
-        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getExecutionId(), null, null, null, null);
+        find = triggerRepository.find(Pageable.from(1, 100, Sort.UNSORTED), searchedTrigger.getExecutionId(), tenant, null, null, null);
         assertThat(find.size()).isEqualTo(1);
         assertThat(find.getFirst().getTriggerId()).isEqualTo(searchedTrigger.getTriggerId());
     }
@@ -178,15 +182,17 @@ public abstract class AbstractTriggerRepositoryTest {
     @Test
     void shouldCountForNullTenant() {
         // Given
+        String tenant = TestsUtils.randomTenant(this.getClass().getSimpleName());
         triggerRepository.save(Trigger
             .builder()
+            .tenantId(tenant)
             .triggerId(IdUtils.create())
             .flowId(IdUtils.create())
             .namespace("io.kestra.unittest")
             .build()
         );
         // When
-        int count = triggerRepository.count(null);
+        int count = triggerRepository.count(tenant);
         // Then
         assertThat(count).isEqualTo(1);
     }

core/src/test/java/io/kestra/core/repositories/ExecutionFixture.java

@@ -1,88 +1,92 @@
 package io.kestra.core.repositories;
 
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
-
 import com.google.common.collect.ImmutableMap;
 import io.kestra.core.models.executions.*;
 import io.kestra.core.models.flows.State;
 import io.kestra.core.utils.IdUtils;
 
-import java.time.Duration;
 import java.util.Collections;
 
 class ExecutionFixture {
-    public static final Execution EXECUTION_1 = Execution.builder()
-        .id(IdUtils.create())
-        .namespace("io.kestra.unittest")
-        .tenantId(MAIN_TENANT)
-        .flowId("full")
-        .flowRevision(1)
-        .state(new State())
-        .inputs(ImmutableMap.of("test", "value"))
-        .taskRunList(Collections.singletonList(
-            TaskRun.builder()
-                .id(IdUtils.create())
-                .namespace("io.kestra.unittest")
-                .flowId("full")
-                .state(new State())
-                .attempts(Collections.singletonList(
-                    TaskRunAttempt.builder()
-                        .build()
-                ))
-                .outputs(Variables.inMemory(ImmutableMap.of(
-                    "out", "value"
-                )))
-                .build()
-        ))
-        .build();
+    public static Execution EXECUTION_1(String tenant) {
+        return Execution.builder()
+            .id(IdUtils.create())
+            .namespace("io.kestra.unittest")
+            .tenantId(tenant)
+            .flowId("full")
+            .flowRevision(1)
+            .state(new State())
+            .inputs(ImmutableMap.of("test", "value"))
+            .taskRunList(Collections.singletonList(
+                TaskRun.builder()
+                    .id(IdUtils.create())
+                    .namespace("io.kestra.unittest")
+                    .flowId("full")
+                    .state(new State())
+                    .attempts(Collections.singletonList(
+                        TaskRunAttempt.builder()
+                            .build()
+                    ))
+                    .outputs(Variables.inMemory(ImmutableMap.of(
+                        "out", "value"
+                    )))
+                    .build()
+            ))
+            .build();
+    }
 
-    public static final Execution EXECUTION_2 = Execution.builder()
-        .id(IdUtils.create())
-        .namespace("io.kestra.unittest")
-        .tenantId(MAIN_TENANT)
-        .flowId("full")
-        .flowRevision(1)
-        .state(new State())
-        .inputs(ImmutableMap.of("test", 1))
-        .taskRunList(Collections.singletonList(
-            TaskRun.builder()
-                .id(IdUtils.create())
-                .namespace("io.kestra.unittest")
-                .flowId("full")
-                .state(new State())
-                .attempts(Collections.singletonList(
-                    TaskRunAttempt.builder()
-                        .build()
-                ))
-                .outputs(Variables.inMemory(ImmutableMap.of(
-                    "out", 1
-                )))
-                .build()
-        ))
-        .build();
+    public static Execution EXECUTION_2(String tenant) {
+        return Execution.builder()
+            .id(IdUtils.create())
+            .namespace("io.kestra.unittest")
+            .tenantId(tenant)
+            .flowId("full")
+            .flowRevision(1)
+            .state(new State())
+            .inputs(ImmutableMap.of("test", 1))
+            .taskRunList(Collections.singletonList(
+                TaskRun.builder()
+                    .id(IdUtils.create())
+                    .namespace("io.kestra.unittest")
+                    .flowId("full")
+                    .state(new State())
+                    .attempts(Collections.singletonList(
+                        TaskRunAttempt.builder()
+                            .build()
+                    ))
+                    .outputs(Variables.inMemory(ImmutableMap.of(
+                        "out", 1
+                    )))
+                    .build()
+            ))
+            .build();
+    }
 
-    public static final Execution EXECUTION_TEST = Execution.builder()
-        .id(IdUtils.create())
-        .namespace("io.kestra.unittest")
-        .flowId("full")
-        .flowRevision(1)
-        .state(new State())
-        .inputs(ImmutableMap.of("test", 1))
-        .kind(ExecutionKind.TEST)
-        .taskRunList(Collections.singletonList(
-            TaskRun.builder()
-                .id(IdUtils.create())
-                .namespace("io.kestra.unittest")
-                .flowId("full")
-                .state(new State())
-                .attempts(Collections.singletonList(
-                    TaskRunAttempt.builder()
-                        .build()
-                ))
-                .outputs(Variables.inMemory(ImmutableMap.of(
-                    "out", 1
-                )))
-                .build()
-        ))
-        .build();
-}
+    public static Execution EXECUTION_TEST(String tenant) {
+        return Execution.builder()
+            .id(IdUtils.create())
+            .namespace("io.kestra.unittest")
+            .tenantId(tenant)
+            .flowId("full")
+            .flowRevision(1)
+            .state(new State())
+            .inputs(ImmutableMap.of("test", 1))
+            .kind(ExecutionKind.TEST)
+            .taskRunList(Collections.singletonList(
+                TaskRun.builder()
+                    .id(IdUtils.create())
+                    .namespace("io.kestra.unittest")
+                    .flowId("full")
+                    .state(new State())
+                    .attempts(Collections.singletonList(
+                        TaskRunAttempt.builder()
+                            .build()
+                    ))
+                    .outputs(Variables.inMemory(ImmutableMap.of(
+                        "out", 1
+                    )))
+                    .build()
+            ))
+            .build();
+    }
+}

core/src/test/java/io/kestra/core/runners/AbstractRunnerTest.java

@@ -1,10 +1,6 @@
 package io.kestra.core.runners;
 
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
-import static org.assertj.core.api.Assertions.assertThat;
-
 import io.kestra.core.junit.annotations.ExecuteFlow;
-import io.kestra.core.junit.annotations.FlakyTest;
 import io.kestra.core.junit.annotations.KestraTest;
 import io.kestra.core.junit.annotations.LoadFlows;
 import io.kestra.core.models.executions.Execution;
@@ -13,36 +9,36 @@ import io.kestra.core.models.flows.State;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
-import io.kestra.plugin.core.flow.EachSequentialTest;
-import io.kestra.plugin.core.flow.FlowCaseTest;
-import io.kestra.plugin.core.flow.ForEachItemCaseTest;
-import io.kestra.plugin.core.flow.PauseTest;
-import io.kestra.plugin.core.flow.LoopUntilCaseTest;
-import io.kestra.plugin.core.flow.WorkingDirectoryTest;
+import io.kestra.plugin.core.flow.*;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
-import java.util.Map;
-import java.util.concurrent.TimeoutException;
-
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
-import org.junitpioneer.jupiter.RetryingTest;
+
+import java.util.Map;
+import java.util.concurrent.TimeoutException;
+
+import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest(startRunner = true)
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+//@org.junit.jupiter.api.parallel.Execution(org.junit.jupiter.api.parallel.ExecutionMode.CONCURRENT)
 // must be per-class to allow calling once init() which took a lot of time
 public abstract class AbstractRunnerTest {
 
+    public static final String TENANT_1 = "tenant1";
+    public static final String TENANT_2 = "tenant2";
     @Inject
-    protected RunnerUtils runnerUtils;
+    protected TestRunnerUtils runnerUtils;
 
     @Inject
     @Named(QueueFactoryInterface.WORKERTASKLOG_NAMED)
     protected QueueInterface<LogEntry> logsQueue;
 
     @Inject
-    private RestartCaseTest restartCaseTest;
+    protected RestartCaseTest restartCaseTest;
 
     @Inject
     protected FlowTriggerCaseTest flowTriggerCaseTest;
@@ -54,13 +50,13 @@ public abstract class AbstractRunnerTest {
     private PluginDefaultsCaseTest pluginDefaultsCaseTest;
 
     @Inject
-    private FlowCaseTest flowCaseTest;
+    protected FlowCaseTest flowCaseTest;
 
     @Inject
     private WorkingDirectoryTest.Suite workingDirectoryTest;
 
     @Inject
-    private PauseTest.Suite pauseTest;
+    protected PauseTest.Suite pauseTest;
 
     @Inject
     private SkipExecutionCaseTest skipExecutionCaseTest;
@@ -72,10 +68,10 @@ public abstract class AbstractRunnerTest {
     protected LoopUntilCaseTest loopUntilTestCaseTest;
 
     @Inject
-    private FlowConcurrencyCaseTest flowConcurrencyCaseTest;
+    protected FlowConcurrencyCaseTest flowConcurrencyCaseTest;
 
     @Inject
-    private ScheduleDateCaseTest scheduleDateCaseTest;
+    protected ScheduleDateCaseTest scheduleDateCaseTest;
 
     @Inject
     protected FlowInputOutput flowIO;
@@ -84,7 +80,7 @@ public abstract class AbstractRunnerTest {
     private SLATestCase slaTestCase;
 
     @Inject
-    private ChangeStateTestCase changeStateTestCase;
+    protected ChangeStateTestCase changeStateTestCase;
 
     @Inject
     private AfterExecutionTestCase afterExecutionTestCase;
@@ -115,7 +111,7 @@ public abstract class AbstractRunnerTest {
         assertThat(execution.getTaskRunList()).hasSize(8);
     }
 
-    @RetryingTest(5)
+    @Test
     @ExecuteFlow("flows/valids/parallel-nested.yaml")
     void parallelNested(Execution execution) {
         assertThat(execution.getTaskRunList()).hasSize(11);
@@ -157,27 +153,27 @@ public abstract class AbstractRunnerTest {
         restartCaseTest.restartFailedThenSuccess();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/restart-each.yaml"})
     void replay() throws Exception {
         restartCaseTest.replay();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/failed-first.yaml"})
     void restartMultiple() throws Exception {
         restartCaseTest.restartMultiple();
     }
 
-    @RetryingTest(5) // Flaky on CI but never locally even with 100 repetitions
+    @Test
     @LoadFlows({"flows/valids/restart_always_failed.yaml"})
     void restartFailedThenFailureWithGlobalErrors() throws Exception {
         restartCaseTest.restartFailedThenFailureWithGlobalErrors();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/restart_local_errors.yaml"})
-    void restartFailedThenFailureWithLocalErrors() throws Exception {
+    protected void restartFailedThenFailureWithLocalErrors() throws Exception {
         restartCaseTest.restartFailedThenFailureWithLocalErrors();
     }
 
@@ -199,29 +195,27 @@ public abstract class AbstractRunnerTest {
         restartCaseTest.restartFailedWithAfterExecution();
     }
 
-    @RetryingTest(5)
-    @LoadFlows({"flows/valids/trigger-flow-listener-no-inputs.yaml",
+    @Test
+    @LoadFlows(value = {"flows/valids/trigger-flow-listener-no-inputs.yaml",
         "flows/valids/trigger-flow-listener.yaml",
         "flows/valids/trigger-flow-listener-namespace-condition.yaml",
-        "flows/valids/trigger-flow.yaml"})
+        "flows/valids/trigger-flow.yaml"}, tenantId = "listener-tenant")
     void flowTrigger() throws Exception {
-        flowTriggerCaseTest.trigger();
+        flowTriggerCaseTest.trigger("listener-tenant");
     }
 
-    @RetryingTest(5) // flaky on CI but never fail locally
+    @Test // flaky on CI but never fail locally
     @LoadFlows({"flows/valids/trigger-flow-listener-with-pause.yaml",
         "flows/valids/trigger-flow-with-pause.yaml"})
     void flowTriggerWithPause() throws Exception {
         flowTriggerCaseTest.triggerWithPause();
     }
 
-    @FlakyTest
-    @Disabled
     @Test
-    @LoadFlows({"flows/valids/trigger-flow-listener-with-concurrency-limit.yaml",
-        "flows/valids/trigger-flow-with-concurrency-limit.yaml"})
-    void flowTriggerWithConcurrencyLimit() throws Exception {
-        flowTriggerCaseTest.triggerWithConcurrencyLimit();
+    @LoadFlows(value = {"flows/valids/trigger-flow-listener-with-concurrency-limit.yaml",
+        "flows/valids/trigger-flow-with-concurrency-limit.yaml"}, tenantId = "trigger-tenant")
+    protected void flowTriggerWithConcurrencyLimit() throws Exception {
+        flowTriggerCaseTest.triggerWithConcurrencyLimit("trigger-tenant");
     }
 
     @Test
@@ -232,12 +226,12 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.trigger();
     }
 
-    @RetryingTest(5) // Flaky on CI but never locally even with 100 repetitions
-    @LoadFlows({"flows/valids/trigger-flow-listener-namespace-condition.yaml",
+    @Test // Flaky on CI but never locally even with 100 repetitions
+    @LoadFlows(value = {"flows/valids/trigger-flow-listener-namespace-condition.yaml",
         "flows/valids/trigger-multiplecondition-flow-c.yaml",
-        "flows/valids/trigger-multiplecondition-flow-d.yaml"})
+        "flows/valids/trigger-multiplecondition-flow-d.yaml"}, tenantId = "condition-tenant")
     void multipleConditionTriggerFailed() throws Exception {
-        multipleConditionTriggerCaseTest.failed();
+        multipleConditionTriggerCaseTest.failed("condition-tenant");
     }
 
     @Test
@@ -248,12 +242,13 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.flowTriggerPreconditions();
     }
 
+    @Disabled
     @Test
-    @LoadFlows({"flows/valids/flow-trigger-preconditions-flow-listen.yaml",
+    @LoadFlows(value = {"flows/valids/flow-trigger-preconditions-flow-listen.yaml",
         "flows/valids/flow-trigger-preconditions-flow-a.yaml",
-        "flows/valids/flow-trigger-preconditions-flow-b.yaml"})
+        "flows/valids/flow-trigger-preconditions-flow-b.yaml"}, tenantId = TENANT_1)
     void flowTriggerPreconditionsMergeOutputs() throws Exception {
-        multipleConditionTriggerCaseTest.flowTriggerPreconditionsMergeOutputs();
+        multipleConditionTriggerCaseTest.flowTriggerPreconditionsMergeOutputs(TENANT_1);
     }
 
     @Test
@@ -262,7 +257,13 @@ public abstract class AbstractRunnerTest {
         multipleConditionTriggerCaseTest.flowTriggerOnPaused();
     }
 
-    @RetryingTest(5)
+    @Test
+    @LoadFlows({"flows/valids/flow-trigger-for-each-item-parent.yaml", "flows/valids/flow-trigger-for-each-item-child.yaml", "flows/valids/flow-trigger-for-each-item-grandchild.yaml"})
+    void forEachItemWithFlowTrigger() throws Exception {
+        multipleConditionTriggerCaseTest.forEachItemWithFlowTrigger();
+    }
+
+    @Test
     @LoadFlows({"flows/valids/each-null.yaml"})
     void eachWithNull() throws Exception {
         EachSequentialTest.eachNullTest(runnerUtils, logsQueue);
@@ -274,28 +275,28 @@ public abstract class AbstractRunnerTest {
         pluginDefaultsCaseTest.taskDefaults();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
         "flows/valids/task-flow-inherited-labels.yaml"})
-    void flowWaitSuccess() throws Exception {
+    protected void flowWaitSuccess() throws Exception {
         flowCaseTest.waitSuccess();
     }
 
     @Test
-    @LoadFlows({"flows/valids/switch.yaml",
+    @LoadFlows(value = {"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
-        "flows/valids/task-flow-inherited-labels.yaml"})
+        "flows/valids/task-flow-inherited-labels.yaml"}, tenantId = TENANT_1)
     void flowWaitFailed() throws Exception {
-        flowCaseTest.waitFailed();
+        flowCaseTest.waitFailed(TENANT_1);
     }
 
     @Test
-    @LoadFlows({"flows/valids/switch.yaml",
+    @LoadFlows(value = {"flows/valids/switch.yaml",
         "flows/valids/task-flow.yaml",
-        "flows/valids/task-flow-inherited-labels.yaml"})
+        "flows/valids/task-flow-inherited-labels.yaml"}, tenantId = TENANT_2)
     public void invalidOutputs() throws Exception {
-        flowCaseTest.invalidOutputs();
+        flowCaseTest.invalidOutputs(TENANT_2);
     }
 
     @Test
@@ -305,9 +306,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/working-directory.yaml"})
+    @LoadFlows(value = {"flows/valids/working-directory.yaml"}, tenantId = TENANT_1)
     public void workerFailed() throws Exception {
-        workingDirectoryTest.failed(runnerUtils);
+        workingDirectoryTest.failed(TENANT_1, runnerUtils);
     }
 
     @Test
@@ -322,7 +323,7 @@ public abstract class AbstractRunnerTest {
         workingDirectoryTest.cache(runnerUtils);
     }
 
-    @RetryingTest(5) // flaky on MySQL
+    @Test // flaky on MySQL
     @LoadFlows({"flows/valids/pause-test.yaml"})
     public void pauseRun() throws Exception {
         pauseTest.run(runnerUtils);
@@ -358,44 +359,44 @@ public abstract class AbstractRunnerTest {
         skipExecutionCaseTest.skipExecution();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/for-each-item-subflow.yaml",
         "flows/valids/for-each-item.yaml"})
     protected void forEachItem() throws Exception {
         forEachItemCaseTest.forEachItem();
     }
 
-    @RetryingTest(5)
-    @LoadFlows({"flows/valids/for-each-item.yaml"})
+    @Test
+    @LoadFlows(value = {"flows/valids/for-each-item.yaml"}, tenantId = TENANT_1)
     protected void forEachItemEmptyItems() throws Exception {
-        forEachItemCaseTest.forEachItemEmptyItems();
+        forEachItemCaseTest.forEachItemEmptyItems(TENANT_1);
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/for-each-item-subflow-failed.yaml",
         "flows/valids/for-each-item-failed.yaml"})
     protected void forEachItemFailed() throws Exception {
         forEachItemCaseTest.forEachItemFailed();
     }
 
-    @RetryingTest(5)
+    @Test
     @LoadFlows({"flows/valids/for-each-item-outputs-subflow.yaml",
         "flows/valids/for-each-item-outputs.yaml"})
     protected void forEachItemSubflowOutputs() throws Exception {
         forEachItemCaseTest.forEachItemWithSubflowOutputs();
     }
 
-    @RetryingTest(5) // flaky on CI but always pass locally even with 100 iterations
-    @LoadFlows({"flows/valids/restart-for-each-item.yaml", "flows/valids/restart-child.yaml"})
+    @Test // flaky on CI but always pass locally even with 100 iterations
+    @LoadFlows(value = {"flows/valids/restart-for-each-item.yaml", "flows/valids/restart-child.yaml"}, tenantId = TENANT_1)
     void restartForEachItem() throws Exception {
-        forEachItemCaseTest.restartForEachItem();
+        forEachItemCaseTest.restartForEachItem(TENANT_1);
     }
 
-    @RetryingTest(5)
-    @LoadFlows({"flows/valids/for-each-item-subflow.yaml",
-        "flows/valids/for-each-item-in-if.yaml"})
+    @Test
+    @LoadFlows(value = {"flows/valids/for-each-item-subflow.yaml",
+        "flows/valids/for-each-item-in-if.yaml"}, tenantId = TENANT_1)
     protected void forEachItemInIf() throws Exception {
-        forEachItemCaseTest.forEachItemInIf();
+        forEachItemCaseTest.forEachItemInIf(TENANT_1);
     }
 
     @Test
@@ -436,9 +437,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/flow-concurrency-for-each-item.yaml", "flows/valids/flow-concurrency-queue.yml"})
+    @LoadFlows(value = {"flows/valids/flow-concurrency-for-each-item.yaml", "flows/valids/flow-concurrency-queue.yml"}, tenantId = TENANT_1)
     protected void flowConcurrencyWithForEachItem() throws Exception {
-        flowConcurrencyCaseTest.flowConcurrencyWithForEachItem();
+        flowConcurrencyCaseTest.flowConcurrencyWithForEachItem(TENANT_1);
     }
 
     @Test
@@ -454,9 +455,15 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/flow-concurrency-subflow.yml", "flows/valids/flow-concurrency-cancel.yml"})
+    @LoadFlows(value = {"flows/valids/flow-concurrency-subflow.yml", "flows/valids/flow-concurrency-cancel.yml"}, tenantId = TENANT_1)
     void flowConcurrencySubflow() throws Exception {
-        flowConcurrencyCaseTest.flowConcurrencySubflow();
+        flowConcurrencyCaseTest.flowConcurrencySubflow(TENANT_1);
+    }
+
+    @Test
+    @LoadFlows({"flows/valids/flow-concurrency-parallel-subflow-kill.yaml", "flows/valids/flow-concurrency-parallel-subflow-kill-child.yaml", "flows/valids/flow-concurrency-parallel-subflow-kill-grandchild.yaml"})
+    void flowConcurrencyParallelSubflowKill() throws Exception {
+        flowConcurrencyCaseTest.flowConcurrencyParallelSubflowKill();
     }
 
     @Test
@@ -511,9 +518,9 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/minimal.yaml"})
+    @LoadFlows(value = {"flows/valids/minimal.yaml"}, tenantId = TENANT_1)
     void shouldScheduleOnDate() throws Exception {
-        scheduleDateCaseTest.shouldScheduleOnDate();
+        scheduleDateCaseTest.shouldScheduleOnDate(TENANT_1);
     }
 
     @Test
@@ -535,15 +542,15 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @LoadFlows({"flows/valids/sla-execution-condition.yaml"})
+    @LoadFlows(value = {"flows/valids/sla-execution-condition.yaml"}, tenantId = TENANT_1)
     void executionConditionSLAShouldCancel() throws Exception {
-        slaTestCase.executionConditionSLAShouldCancel();
+        slaTestCase.executionConditionSLAShouldCancel(TENANT_1);
     }
 
     @Test
-    @LoadFlows({"flows/valids/sla-execution-condition.yaml"})
+    @LoadFlows(value = {"flows/valids/sla-execution-condition.yaml"}, tenantId = TENANT_2)
     void executionConditionSLAShouldLabel() throws Exception {
-        slaTestCase.executionConditionSLAShouldLabel();
+        slaTestCase.executionConditionSLAShouldLabel(TENANT_2);
     }
 
     @Test
@@ -563,15 +570,15 @@ public abstract class AbstractRunnerTest {
     }
 
     @Test
-    @ExecuteFlow("flows/valids/failed-first.yaml")
+    @ExecuteFlow(value = "flows/valids/failed-first.yaml", tenantId = TENANT_1)
     public void changeStateShouldEndsInSuccess(Execution execution) throws Exception {
         changeStateTestCase.changeStateShouldEndsInSuccess(execution);
     }
 
     @Test
-    @LoadFlows({"flows/valids/failed-first.yaml", "flows/valids/subflow-parent-of-failed.yaml"})
+    @LoadFlows(value = {"flows/valids/failed-first.yaml", "flows/valids/subflow-parent-of-failed.yaml"}, tenantId = TENANT_2)
     public void changeStateInSubflowShouldEndsParentFlowInSuccess() throws Exception {
-        changeStateTestCase.changeStateInSubflowShouldEndsParentFlowInSuccess();
+        changeStateTestCase.changeStateInSubflowShouldEndsParentFlowInSuccess(TENANT_2);
     }
 
     @Test

core/src/test/java/io/kestra/core/runners/ChangeStateTestCase.java

@@ -3,25 +3,18 @@ package io.kestra.core.runners;
 import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.flows.Flow;
 import io.kestra.core.models.flows.State;
-import io.kestra.core.queues.QueueFactoryInterface;
-import io.kestra.core.queues.QueueInterface;
+import io.kestra.core.models.flows.State.Type;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.ExecutionService;
-import io.kestra.core.utils.TestsUtils;
 import jakarta.inject.Inject;
-import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import reactor.core.publisher.Flux;
 
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static io.kestra.core.tenant.TenantService.MAIN_TENANT;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @Singleton
 public class ChangeStateTestCase {
+
+    public static final String NAMESPACE = "io.kestra.tests";
     @Inject
     private FlowRepositoryInterface flowRepository;
 
@@ -29,11 +22,7 @@ public class ChangeStateTestCase {
     private ExecutionService executionService;
 
     @Inject
-    @Named(QueueFactoryInterface.EXECUTION_NAMED)
-    private QueueInterface<Execution> executionQueue;
-
-    @Inject
-    private RunnerUtils runnerUtils;
+    private TestRunnerUtils runnerUtils;
 
     public void changeStateShouldEndsInSuccess(Execution execution) throws Exception {
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
@@ -41,73 +30,40 @@ public class ChangeStateTestCase {
         assertThat(execution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         // await for the last execution
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Execution> lastExecution = new AtomicReference<>();
-        Flux<Execution> receivedExecutions = TestsUtils.receive(executionQueue, either -> {
-            Execution exec = either.getLeft();
-            if (execution.getId().equals(exec.getId()) && exec.getState().getCurrent() == State.Type.SUCCESS) {
-                lastExecution.set(exec);
-                latch.countDown();
-            }
-        });
-
         Flow flow = flowRepository.findByExecution(execution);
         Execution markedAs = executionService.markAs(execution, flow, execution.getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
-        executionQueue.emit(markedAs);
+        Execution lastExecution = runnerUtils.emitAndAwaitExecution(e -> e.getState().getCurrent().equals(Type.SUCCESS), markedAs);
 
-        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
-        receivedExecutions.blockLast();
-        assertThat(lastExecution.get().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
-        assertThat(lastExecution.get().getTaskRunList()).hasSize(2);
-        assertThat(lastExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(lastExecution.getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(lastExecution.getTaskRunList()).hasSize(2);
+        assertThat(lastExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
     }
 
-    public void changeStateInSubflowShouldEndsParentFlowInSuccess() throws Exception {
-        // await for the subflow execution
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicReference<Execution> lastExecution = new AtomicReference<>();
-        Flux<Execution> receivedExecutions = TestsUtils.receive(executionQueue, either -> {
-            Execution exec = either.getLeft();
-            if ("failed-first".equals(exec.getFlowId()) && exec.getState().getCurrent() == State.Type.FAILED) {
-                lastExecution.set(exec);
-                latch.countDown();
-            }
-        });
-
+    public void changeStateInSubflowShouldEndsParentFlowInSuccess(String tenantId) throws Exception {
         // run the parent flow
-        Execution execution = runnerUtils.runOne(MAIN_TENANT, "io.kestra.tests", "subflow-parent-of-failed");
+        Execution execution = runnerUtils.runOne(tenantId, NAMESPACE, "subflow-parent-of-failed");
         assertThat(execution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
         assertThat(execution.getTaskRunList()).hasSize(1);
         assertThat(execution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         // assert on the subflow
-        assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue();
-        receivedExecutions.blockLast();
-        assertThat(lastExecution.get().getState().getCurrent()).isEqualTo(State.Type.FAILED);
-        assertThat(lastExecution.get().getTaskRunList()).hasSize(1);
-        assertThat(lastExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
-
-        // await for the parent execution
-        CountDownLatch parentLatch = new CountDownLatch(1);
-        AtomicReference<Execution> lastParentExecution = new AtomicReference<>();
-        receivedExecutions = TestsUtils.receive(executionQueue, either -> {
-            Execution exec = either.getLeft();
-            if (execution.getId().equals(exec.getId()) && exec.getState().isTerminated()) {
-                lastParentExecution.set(exec);
-                parentLatch.countDown();
-            }
-        });
+        Execution lastExecution = runnerUtils.awaitFlowExecution(e -> e.getState().getCurrent().equals(Type.FAILED), tenantId, NAMESPACE, "failed-first");
+        assertThat(lastExecution.getState().getCurrent()).isEqualTo(State.Type.FAILED);
+        assertThat(lastExecution.getTaskRunList()).hasSize(1);
+        assertThat(lastExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.FAILED);
 
         // restart the subflow
-        Flow flow = flowRepository.findByExecution(lastExecution.get());
-        Execution markedAs = executionService.markAs(lastExecution.get(), flow, lastExecution.get().getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
-        executionQueue.emit(markedAs);
+        Flow flow = flowRepository.findByExecution(lastExecution);
+        Execution markedAs = executionService.markAs(lastExecution, flow, lastExecution.getTaskRunList().getFirst().getId(), State.Type.SUCCESS);
+        runnerUtils.emitAndAwaitExecution(e -> e.getState().isTerminated(), markedAs);
+
+        //We wait for the subflow execution to pass from failed to success
+        Execution lastParentExecution = runnerUtils.awaitFlowExecution(e ->
+            e.getTaskRunList().getFirst().getState().getCurrent().equals(Type.SUCCESS), tenantId, NAMESPACE, "subflow-parent-of-failed");
 
         // assert for the parent flow
-        assertThat(parentLatch.await(10, TimeUnit.SECONDS)).isTrue();
-        receivedExecutions.blockLast();
-        assertThat(lastParentExecution.get().getState().getCurrent()).isEqualTo(State.Type.FAILED); // FIXME should be success but it's FAILED on unit tests
-        assertThat(lastParentExecution.get().getTaskRunList()).hasSize(1);
-        assertThat(lastParentExecution.get().getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
+        assertThat(lastParentExecution.getState().getCurrent()).isEqualTo(State.Type.FAILED); // FIXME should be success but it's FAILED on unit tests
+        assertThat(lastParentExecution.getTaskRunList()).hasSize(1);
+        assertThat(lastParentExecution.getTaskRunList().getFirst().getState().getCurrent()).isEqualTo(State.Type.SUCCESS);
     }
 }

core/src/test/java/io/kestra/core/runners/CustomVariableRendererTest.java

@@ -1,58 +0,0 @@
-package io.kestra.core.runners;
-
-import io.kestra.core.exceptions.IllegalVariableEvaluationException;
-import io.kestra.core.junit.annotations.KestraTest;
-import io.micronaut.context.ApplicationContext;
-import io.micronaut.context.annotation.Factory;
-import io.micronaut.context.annotation.Primary;
-import io.micronaut.context.annotation.Requires;
-import io.micronaut.test.annotation.MockBean;
-import jakarta.inject.Inject;
-import jakarta.inject.Singleton;
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@KestraTest
-class CustomVariableRendererTest {
-    
-    @Inject
-    private SecureVariableRendererFactory secureVariableRendererFactory;
-    
-    @Inject
-    private VariableRenderer renderer;
-    
-    @Test
-    void shouldUseCustomVariableRender() throws IllegalVariableEvaluationException {
-        // When
-        String result = renderer.render("{{ dummy }}", Map.of());
-        
-        // Then
-        assertThat(result).isEqualTo("alternativeRender");
-    }
-    
-    @Test
-    void shouldUseCustomVariableRenderWhenUsingSecured() throws IllegalVariableEvaluationException {
-        // Given
-        VariableRenderer renderer = secureVariableRendererFactory.createOrGet();
-        
-        // When
-        String result = renderer.render("{{ dummy }}", Map.of());
-        
-        // Then
-        assertThat(result).isEqualTo("alternativeRender");
-    }
-    
-    @MockBean(VariableRenderer.class)
-    VariableRenderer testCustomRenderer(ApplicationContext applicationContext) {
-        return new VariableRenderer(applicationContext, null) {
-            
-            @Override
-            protected String alternativeRender(Exception e, String inline, Map<String, Object> variables) {
-                return "alternativeRender";
-            }
-        };
-    }
-}

core/src/test/java/io/kestra/core/runners/EmptyVariablesTest.java

@@ -18,7 +18,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 public class EmptyVariablesTest {
 
     @Inject
-    private RunnerUtils runnerUtils;
+    private TestRunnerUtils runnerUtils;
     @Inject
     private FlowInputOutput flowIO;