Aller au contenu

Guide d'installation

Cette page décrit comment installer un à un les composants de Squash pour le support des tests automatisés.

Légende

️💎 indique un composant ou une fonctionnalité Ultimate. Une vue d'ensemble des fonctionnalités Premium et Ultimate est disponible ici. Pour en bénéficier ou demander plus d'informations, consulter notre site ou nous contacter.

Squash Orchestrator

Vignette installation orchestrateur

Installation

L'installation de Squash Orchestrator consiste à déployer une image Docker. Elle contient l'ensemble des services nécessaires de l'OpenTestFactory Orchestrator et des services spécifiques Squash.

Pour récupérer la dernière version de l'image de Squash Orchestrator, la commande suivante est à exécuter : 

docker pull squashtest/squash-orchestrator:4.11.0

Les préconisations pour dimensionner le conteneur Docker sont :

  • CPU : 1,5
  • RAM : 1,5 Go minimum
  • disque : prévoir la capacité de stocker les rapports d’exécution et leurs attachements pour une heure d'utilisation

Dépannage - Accessibilité de l'instance Squash TM

Vérifier que l'instance de Squash TM est accessible depuis Squash Orchestrator. Pour cela se mettre sur l'hôte Docker et exécuter la commande (en remplaçant https://squashtm.example.com/squash par l'URL de votre instance) : 

curl https://squashtm.example.com/squash/isSquashAlive
La réponse doit être : 
Squash is Alive!
Si ce n'est pas le cas, résoudre le problème avec les administrateurs de votre réseau.

Usage

Configuration de la licence Ultimate💎

Les services réservés à Squash Ultimate sont accessibles si vous fournissez la licence Squash Ultimate squash-tm.lic (le même fichier que celui utilisé pour Squash TM) dans le conteneur de Squash Orchestrator.

Cette licence peut être montée de deux manières:

  • dans le conteneur dans un sous-répertoire license du répertoire /app (c'est-à-dire /app/license/squash-tm.lic)

  • dans un répertoire défini par la variable d'environnement LICENSE_PATH (c'est-à-dire {LICENSE_PATH}/license/squash-tm.lic).

Version Community ou licence Premium👑

Si vous utilisez Squash Community ou Squash Premium👑, ne déclarez pas de fichier de licence (ignorez les lignes mises en surbrillance dans les exemples de commandes ci-dessous).

Utilisation de Docker

L'exécution de la commande suivante démarrera le Squash Orchestrator en utilisant un environnement d'exécution existant, avec des clés auto-générées de confiance (ce qui n'est pas recommandé dans une configuration de production) :

docker run -d \
         --name orchestrator \
         -p 7774:7774 \
         -p 7775:7775 \
         -p 7776:7776 \
         -p 7796:7796 \
         -p 38368:38368 \
         -p 34537:34537 \
         -p 24368:24368 \
         -p 12312:12312 \
         -e SSH_CHANNEL_HOST=the_environment_ip_or_hostname \
         -e SSH_CHANNEL_USER=user \
         -e SSH_CHANNEL_PASSWORD=secret \
         -e SSH_CHANNEL_TAGS=ssh,linux,robotframework \
         -v ./path/to/my/squash-tm.lic:/app/license/squash-tm.lic \
         squashtest/squash-orchestrator:4.11.0

docker run -d ^
         --name orchestrator ^
         -p 7774:7774 ^
         -p 7775:7775 ^
         -p 7776:7776 ^
         -p 7796:7796 ^
         -p 38368:38368 ^
         -p 34537:34537 ^
         -p 24368:24368 ^
         -p 12312:12312 ^
         -e SSH_CHANNEL_HOST=the_environment_ip_or_hostname ^
         -e SSH_CHANNEL_USER=user ^
         -e SSH_CHANNEL_PASSWORD=secret ^
         -e SSH_CHANNEL_TAGS=ssh,linux,robotframework ^
         -v ./path/to/my/squash-tm.lic:/app/license/squash-tm.lic ^
         squashtest/squash-orchestrator:4.11.0

docker run -d `
         --name orchestrator `
         -p 7774:7774 `
         -p 7775:7775 `
         -p 7776:7776 `
         -p 7796:7796 `
         -p 38368:38368 `
         -p 34537:34537 `
         -p 24368:24368 `
         -p 12312:12312 `
         -e SSH_CHANNEL_HOST=the_environment_ip_or_hostname `
         -e SSH_CHANNEL_USER=user `
         -e SSH_CHANNEL_PASSWORD=secret `
         -e SSH_CHANNEL_TAGS=ssh,linux,robotframework `
         -v ./path/to/my/squash-tm.lic:/app/license/squash-tm.lic `
         squashtest/squash-orchestrator:4.11.0

Cette commande expose les services suivants sur les ports correspondants :

Si vous ne prévoyez pas de déclarer des agents, le port 24368 peut ne pas être exposé. De la même manière, si vous ne prévoyez pas d'utiliser la quality gate, le port 12312 peut ne pas être exposé.

Rappelle

Vous pouvez remplacer /app par votre propre chemin et déclarer la variable d'environnement LICENSE_PATH pointant vers le répertoire de votre choix:

-e LICENSE_PATH=/chemin/vers/mon/répertoire \
-v ./path/to/my/squash-tm.lic:/chemin/vers/mon/répertoire/license/squash-tm.lic \

Vous pouvez consulter les logs du conteneur :

docker logs orchestrator

Pour supprimer le conteneur, utilisez les commandes suivantes :

docker kill orchestrator
docker rm orchestrator

Utilisation de docker-compose

Dans un nouveau dossier, créez un répertoire data dans lequel vous placerez votre clef publique et un sous-répertoire licenseavec le fichier de licence squash-tm.lic.

arborescence cible
+-- dossier
     +-- .env
     +-- data
     |    +-- trusted_key.pub
     |    +-- license
     |         +-- squash-tm.lic
     +-- docker-compose.yml

Créez également un fichier .env qui centralisera les versions des composants que vous utiliserez :

.env
ORCHESTRATOR_VERSION=4.11.0
TOKEN=ey...

Créez enfin le fichier docker-compose.yml suivant :

docker-compose.yml
# docker-compose up -d
version: "3.4"
services:

# Squash Orchestrator
orchestrator:
    container_name: orchestrator      
    image: squashtest/squash-orchestrator:$ORCHESTRATOR_VERSION
    restart: always
    volumes:
    - type: bind
    source: ./data/trusted_key.pub
    target: /etc/squashtf/squash.pub
    - type: bind
    source: ./data/license/squash-tm.lic
    target: /app/license/squash-tm.lic
    ports:
    - "7774:7774"
    - "7775:7775"
    - "7776:7776"
    - "7796:7796"
    - "38368:38368"
    - "34537:34537"
    - "24368:24368"
    - "12312:12312"
docker-compose.yml
# docker-compose up -d
version: "3.4"
services:

# Squash Orchestrator
orchestrator:
    container_name: orchestrator      
    image: squashtest/squash-orchestrator:$ORCHESTRATOR_VERSION
    restart: always
    volumes:
    - type: bind
    source: ./data/trusted_key.pub
    target: /etc/squashtf/squash.pub
    - type: bind
    source: ./data/license/squash-tm.lic
    target: /chemin/vers/mon/répertoire/license/squash-tm.lic
    environment:
    - LICENSE_PATH=/chemin/vers/mon/répertoire
    ports:
    - "7774:7774"
    - "7775:7775"
    - "7776:7776"
    - "7796:7796"
    - "38368:38368"
    - "34537:34537"
    - "24368:24368"
    - "12312:12312"

Pour lancer Squash Orchestrator, placez-vous dans ce dossier et utilisez la commande suivante :

docker compose up -d

Vous pouvez consulter les logs de ce déploiement en utilisant la commande suivante :

docker compose logs

Pour arrêter Squash Orchestrator , placez-vous dans le dossier et utilisez la commande suivante :

docker compose down

Utilisation de Kubernetes

L'exemple suivant déploie un pod contenant Squash Orchestrator .

squash-autom.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: squash-autom
  name: squash-autom
spec:
  replicas: 1
  selector:
    matchLabels:
      app: squash-autom
  template:
    metadata:
      labels:
        app: squash-autom
    spec:
      containers:
      - name: orchestrator
        image: squashtest/squash-orchestrator:4.11.0
        imagePullPolicy: Always
        ports:
        - containerPort: 7774
          protocol: TCP
        - containerPort: 7775
          protocol: TCP
        - containerPort: 7776
          protocol: TCP
        - containerPort: 7796
          protocol: TCP
        - containerPort: 38368
          protocol: TCP
        - containerPort: 34537
          protocol: TCP
        - containerPort: 24368
          protocol: TCP
        - containerPort: 12312
          protocol: TCP
        resources:
          limits:
            memory: 1.5G
          requests:
            cpu: "1.5"
            memory: 1.5G
        volumeMounts:
        - mountPath: /etc/squashtf
          name: squash-orchestrator-trusted-key
        - mountPath: /app/license
          name: squash-license
      volumes:
      - name: squash-orchestrator-trusted-key
        secret:
          defaultMode: 420
          secretName: trusted-keys
      - name: squash-license
        secret:
          secretName: squash-license
---
apiVersion: v1
kind: Service
metadata:
  name: squash-autom
spec:
  selector:
    app: squash-autom
  ports:
  - name: receptionist
    port: 7774
    protocol: TCP
    targetPort: 7774
  - name: eventbus
    port: 38368
    protocol: TCP
    targetPort: 38368
  - name: localstore
    port: 34537
    protocol: TCP
    targetPort: 34537
  - name: insightcollector
    port: 7796
    protocol: TCP
    targetPort: 7796
  - name: observer
    port: 7775
    protocol: TCP
    targetPort: 7775
  - name: killswitch
    port: 7776
    protocol: TCP
    targetPort: 7776
  - name: agentchannel
    port: 24368
    protocol: TCP
    targetPort: 24368
  - name: qualitygate
    port: 12312
    protocol: TCP
    targetPort: 12312

Pour déployer ce pod et ce service sur votre cluster Kubernetes, créez un namespace (ou utilisez un namespace déjà existant) :

kubectl create namespace my-namespace

Créez alors un secret contenant votre clef publique et la licence, déployez ce secret dans le namespace que vous venez de créer :

kubectl create secret generic trusted-keys --from-file=trusted_key.pub=trusted_key.pub --namespace my-namespace
kubectl create secret generic squash-license --from-file=squash-tm.lic=squash-tm.lic --namespace my-namespace

Déployez enfin le pod et le service :

kubectl apply -f squash-autom.yaml --namespace my-namespace

Pour supprimer le pod, utilisez la commande suivante :

kubectl delete -f squash-autom.yaml --namespace my-namespace

Configuration avec des clefs pré-générées

Hors expérimentation, il est recommandé de démarrer Squash Orchestrator en précisant une ou plusieurs clefs publiques qui seront utilisées pour valider les jetons authentifiant les requêtes entrantes.

Les commandes suivantes permettent de générer une paire de clef trusted_key.pem / trusted_key.pub (vous pouvez en générer plusieurs si vous le souhaitez) :

openssl genrsa -out trusted_key.pem 4096
openssl rsa -pubout -in trusted_key.pem -out trusted_key.pub

Si vos clefs publiques (*.pub) sont dans un répertoire public_keys, voici un exemple les rendant accessibles à l'orchestrateur (tous les fichiers dans ce répertoire seront accessibles à l'orchestrateur, n'y placez pas vos clefs privées) :

docker run ... \
           -v /path/to/public_keys:/etc/squashtf \
           ...

docker run ... ^
           -v d:\path\to\public_keys:/etc/squashtf ^
           ...

docker run ... `
           -v d:\path\to\public_keys:/etc/squashtf `
           ...

Si vous ne prévoyez d'utiliser qu'une clef publique, vous pouvez la rendre accessible directement :

docker run ... \
           -v /path/to/public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub \
           ...

docker run ... ^
           -v d:\path\to\public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub ^
           ...

docker run ... `
           -v d:\path\to\public_keys/trusted_key.pub:/etc/squashtf/trusted_key.pub `
           ...

Les jetons vérifiés par ces clefs auront un accès complet au namespace default. Ce comportement peut être modifié en modifiant la configuration de l'image.

Pour les détails sur le déploiement de Squash Orchestrator, vous pouvez vous reporter à la documentation de l'OpenTestFactory qui sert de base au Squash Orchestrator (le déploiement des deux orchestrateurs est similaire). Cette documentation détaille aussi les cas spécifiques d'un déploiement avec docker-compose ou avec Kubernetes.

Utilisation de certificats auto-signés

Une FAQ détaille comment utiliser Squash Orchestrator avec des certificats auto-signés.

Outils de l'orchestrateur

Vignette installation outils

Installation

Les outils de l'orchestrateur sont destinés à simplifier l'exploitation de ce dernier. Ils peuvent être installés sur n'importe quelle machine d'où on veut pouvoir administrer l'orchestrateur.
Ils requièrent Python 3.8 ou supérieur. Ils fonctionnent sur un environnement Linux, macOS ou Windows.

Afin d'installer ces outils depuis PyPI, la commande suivante est à exécuter :

pip install --upgrade opentf-tools

Aperçu des capacités des outils

  • opentf-ready attend que l'orchestrateur soit prêt à accepter les workflows.

  • opentf-done attend que l'orchestrateur puisse être arrêté en toute sécurité (c'est-à-dire qu'il n'a plus de tâches en attente).

  • opentf-ctl peut être utilisé pour

    • démarrer / suivre / arrêter un workflow
    • générer un jeton signé
    • lister les agents
    • générer / modifier un fichier de configuration
    • …

Génération d'un jeton signé

Les requêtes à destination de Squash Orchestrator doivent être associées à des jetons signés.

Étant donné une clef privée trusted_key.pem dans le répertoire courant, la commande suivante permet de générer un jeton signé qui sera reconnu par l'orchestrateur s'il connaît la clef publique correspondante :

opentf-ctl generate token using trusted_key.pem

Please specify an algorithm (RS512 if unspecified):
The specified algorithm is: RS512
Please enter the issuer (your company or department): acme
Please enter the subject (you or the person you are making this token for): charlie
The signed token is:
ey...

Détails

Une description complète des outils est disponible dans la documentation d'OpenTestFactory.

Agent OpenTestFactory

Vignette installation agent

Installation

L'agent OpenTestFactory est une application Python à installer sur un environnement d'exécution de tests automatisés. Il requiert Python 3.7 ou supérieur. Il fonctionne sur un environnement Linux, macOS ou Windows.

L'agent se présente comme un simple script. Il possède seulement une dépendance, vers la librairie Python requests (elle sera installée si elle n'est pas déjà présente sur l'environnement d'exécution).

Afin d'installer l'agent depuis PyPI, la commande suivante est à exécuter :

pip install --upgrade opentf-agent

Vous pouvez vérifier l'installation en exécutant la commande suivante :

opentf-agent --help

Usage

Résumé

$ opentf-agent --help
usage: opentf-agent [-h] --tags TAGS --host HOST [--port PORT] [--path_prefix PATH_PREFIX] [--token TOKEN] [--encoding ENCODING] [--script_path SCRIPT_PATH] [--workspace_dir WORKSPACE_DIR] [--name NAME] [--polling_delay POLLING_DELAY] [--liveness_probe LIVENESS_PROBE] [--retry RETRY] [--debug]

OpenTestFactory Agent

optional arguments:
  -h, --help            show this help message and exit
  --tags TAGS           a comma-separated list of tags (e.g. windows,robotframework)
  --host HOST           target host with protocol (e.g. https://example.local)
  --port PORT           target port (default to 24368)
  --path_prefix PATH_PREFIX
                        target context path (default to no context path)
  --token TOKEN         token
  --encoding ENCODING   encoding on the console side (defaults to utf-8)
  --script_path SCRIPT_PATH
                        where to put temporary files (defaults to current directory)
  --workspace_dir WORKSPACE_DIR
                        where to put workspaces (defaults to current directory)
  --name NAME           agent name (defaults to "test agent")
  --polling_delay POLLING_DELAY
                        polling delay in seconds (default to 5)
  --liveness_probe LIVENESS_PROBE
                        liveness probe in seconds (default to 300 seconds)
  --retry RETRY         how many time to try joining host (default to 5,
                        0 = try forever)
  --debug               whether to log debug informations.

Exemple

En considérant qu'un Squash Orchestrator est lancé sur orchestrator.example.com, avec un jeton stocké dans la variable d'environnement TOKEN, la commande suivante enregistre l'environnement d'exécution Windows et recevra les commandes ciblant windows et/ou robotframework :

chcp 65001
opentf-agent --tags windows,robotframework --host http://orchestrator.example.com/ --token %TOKEN%

L'agent contactera l'orchestrateur toutes les 5 secondes, et exécutera les commandes réceptionnées.
La commande chcp configure la console en Unicode. Il s'agit d'une spécificité Windows. Cette configuration peut être nécessaire suivant le framework de test disponible sur l'environnement d'exécution.

Détails

Une description complète de l'agent est disponible dans la documentation d'OpenTestFactory.

Environnements d'exécution

Vignette installation environnement d'exécution

Certaines technologies de test nécessitent que des composants particuliers soient installés dans l'environnement d'exécution, ceux-ci sont indiqués dans les pages décrivant les spécificités de chaque technologie.

Plugins Squash TM

Vignette installation des Plugins TM pour Squash

Installation

Pour l’installation des plugins Squash TM, merci de vous reporter au protocole d’installation d’un plugin Squash TM.

Plugin Version de Squash TM Version compatible du plugin Télécharger la dernière version Community Télécharger la dernière version Ultimate💎
Test Plan Retriever

Attention

Test Plan Retriever Ultimate nécessite de démarrer Squash Orchestrator en mode Premium, voir ici.
4.0.0, ou 4.X.Y postérieure 4.0.X 4.0.0 : .tar.gz ou .zip 4.0.0 : .tar.gz ou .zip
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar.gz ou .zip 5.0.0 : .tar.gz ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.0 : .tar.gz ou .zip 6.0.0 : .tar.gz ou .zip
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip 7.0.0 : .tar.gz ou .zip
Result Publisher 4.0.0, ou 4.0.X postérieure 4.0.X 4.0.0 : .tar.gz ou .zip 4.0.0 : .tar.gz ou .zip
4.1.0, ou 4.X.Y postérieure 4.1.X 4.1.0 : .tar.gz ou .zip 4.1.0 : .tar.gz ou .zip
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar.gz ou .zip 5.0.0 : .tar.gz ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.1 : .tar.gz ou .zip À partir de Squash TM 6.0.0,
il n'existe plus de version Ultimate.
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip
Squash AUTOM 4.0.0, ou 4.0.X postérieure 4.0.X 4.0.1 : .tar.gz ou .zip 4.0.1 : .tar.gz ou .zip
4.1.0, ou 4.X.Y postérieure 4.1.X 4.1.0 : .tar.gz ou .zip 4.1.0 : .tar.gz ou .zip
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar.gz ou .zip 5.0.0 : .tar.gz ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.0 : .tar.gz ou .zip 6.0.0 : .tar.gz ou .zip
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip 7.0.0 : .tar.gz ou .zip
Git Connector 4.0.0, ou 4.X.Y postérieure 4.0.X 4.0.0 : .tar.gz ou .zip pas de version Ultimate
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar.gz ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.0 : .tar.gz ou .zip
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip
Actions Library 4.0.0, ou 4.X.Y postérieure 4.0.X pas de version Community 4.0.0 : .tar.gz ou .zip
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar.gz ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.0 : .tar.gz ou .zip
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip
Workflow Automatisation Jira 4.0.0, ou 4.X.Y postérieure 4.0.X pas de version Community 4.0.0 : .tar ou .zip
5.0.0, ou 5.X.Y postérieure 5.0.X 5.0.0 : .tar ou .zip
6.0.0, ou 6.X.Y postérieure 6.0.X 6.0.0 : .tar ou .zip
7.0.0, ou 7.X.Y postérieure 7.0.X 7.0.0 : .tar.gz ou .zip

Configuration de Squash TM

Vignette configuration TM

Attention

Squash AUTOM nécessite que l'URL publique de Squash TM soit définie (voir la documentation de Squash TM).

Déclaration du serveur Squash Orchestrator

Afin de lancer un plan d'exécution manuellement depuis Squash TM, il est nécessaire de déclarer le Squash Orchestrator qui exécutera les tests automatisés dans les environnements adaptés.
Cette déclaration se fait dans la section Serveurs d'exécution automatisée de l'espace Administration :

Déclaration du serveur d'automatisation

Déclaration du serveur d'automatisation

  • Nom : Le nom du serveur tel qu'il apparaîtra dans l'espace Cas de test.

  • Type : Sélectionnez squashAutom dans la liste déroulante.

  • Url : L'adresse du Receptionist de Squash Orchestrator.

Attention

L'Event Bus de Squash Orchestrator doit impérativement être accessible à la même URL que le Receptionist mais sur le port 38368.

Les URLs

  • du Receptionist et
  • de l'Observer si différente (par exemple, si le Squash Orchestrator n'est pas situé derrière un reverse-proxy)

doivent être déclarées :

Configuration des URL

Les URLs

  • du Receptionist,
  • de l'Observer si différente (par exemple, si le Squash Orchestrator n'est pas situé derrière un reverse-proxy) et
  • de l'Event Bus si différente (même commentaire)

doivent être déclarées :

Configuration des URL

Les URLs

  • du Receptionist,
  • de l'Observer si différente (par exemple, si le Squash Orchestrator n'est pas situé derrière un reverse-proxy),
  • de l'Event Bus si différente (même commentaire) et
  • du Killswitch si différente (même commentaire)

doivent être déclarées :

Configuration des URL

Une fois le serveur créé, vous devez préciser un token servant pour l'authentification au serveur.

Token

Dépannage - Accessibilité du Squash Orchestrator

Il est possible de vérifier que la connexion au Squash Orchestrator (depuis le serveur hébergeant Squash TM) fonctionne correctement en l'interrogeant, par exemple en demandant la liste des environnements d'exécution : 

curl --header "Authorization: bearer <token>" <Observer URL>/channels
où

  • <token> est le token d'authentification au Squash Orchestrator.
  • <Observer URL>est l'URL de l'Observer.

La réponse devrait être de la forme : 

{"apiVersion":"v1","code":200,"details":{"items":[{"apiVersion":"opentestfactory.org/v1alpha1","kind":"Channel","metadata":{"channelhandler_id":"907f43e2-b5a0-4594-a1c7-31f6bf667b38","name":"dummy.example.com","namespaces":"default"},"spec":{"tags":["ssh","linux"]},"status":{"currentJobID":null,"lastCommunicationTimestamp":"2022-09-16T12:18:01.640489","phase":"IDLE"}}]},"kind":"Status","message":"Known channels","metadata":{},"reason":"OK","status":"Success"}

L'image docker de Squash TM ne contient pas curl. Vous pouvez utiliser à la place wget: 

 docker exec <Squash TM container> wget --header="Authorization: bearer <token>" -O - <Observer URL>/channels
où

  • <Squash TM container> est le nom du container.
  • <token> est le token d'authentification au Squash Orchestrator.
  • <Observer URL>est l'URL de l'Observer.

La réponse devrait être de la forme : 

Connecting to 172.17.0.1:7775 (172.17.0.1:7775)
writing to stdout
-                    100% |********************************|   464  0:00:00 ETA
written to stdout
{"apiVersion":"v1","code":200,"details":{"items":[{"apiVersion":"opentestfactory.org/v1alpha1","kind":"Channel","metadata":{"channelhandler_id":"907f43e2-b5a0-4594-a1c7-31f6bf667b38","name":"dummy.example.com","namespaces":"default"},"spec":{"tags":["ssh","linux"]},"status":{"currentJobID":null,"lastCommunicationTimestamp":"2022-09-16T12:18:01.640489","phase":"IDLE"}}]},"kind":"Status","message":"Known channels","metadata":{},"reason":"OK","status":"Success"}

Configuration du projet Squash TM

Une fois un serveur d'automatisation déclaré, il faut le lier à un projet Squash TM afin qu'il soit utilisé pour l'exécution des cas de test automatisés du projet.

La marche à suivre est la suivante :

  1. Allez dans l'espace [Administration], puis cliquez sur [Projets].

  2. Sélectionnez un projet existant, puis allez jusqu'à la section Automatisation. Configuration de l'automatisation d'un projet

  3. Cliquez sur Pas de serveur, une liste déroulante contenant les serveurs d'automatisation déclarés apparaît. Configuration de l'automatisation d'un projet

  4. Sélectionnez le serveur et confirmez la sélection.

Plugin pour Jenkins

Vignette installation Plugin Jenkins

Installation

Le plugin est sous la forme d’un fichier .hpi (opentestfactory-orchestrator-2.2.0.hpi) librement téléchargeable.

Pour l’installation, soumettez le plugin depuis l’onglet Avancé de l’écran de gestion des plugins de Jenkins :

Soumission du plugin Jenkins

Compatibilité du plugin

Ce plugin est compatible avec une version 2.357 ou supérieure de Jenkins.

Version de Java

Les versions 2.0.0 et ultérieures du Plugin pour Jenkins nécessitent Java 11 qui est également requis pour Jenkins 2.357 ou ultérieur (voir l'annonce de Jenkins). Cela signifie que

  • si vous utilisez Jenkins version 2.357 ou ultérieure, vous devez utiliser le Plugin pour Jenkins 2.0.0 ou ultérieur ;
  • sinon, vous devez utiliser une version 1.x.y du Plugin pour Jenkins (qui est compatible avec les versions Jenkins de 2.164.1 jusqu'à 2.356) ; la dernière telle version, opentestfactory-orchestrator-1.4.0.hpi, est téléchargeable ici.