SAP Piper Pipeline pour ABAP Cloud : CI/CD avec Jenkins

┌──────────────────────────────────────────────────────────────────────────┐
│                        Architecture SAP Piper                             │
│                                                                           │
│  ┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐       │
│  │   Piper CLI     │    │  Piper Library  │    │   Docker Images │       │
│  │   (Go-Binary)   │    │  (Shared Lib)   │    │   (Build Env)   │       │
│  └────────┬────────┘    └────────┬────────┘    └────────┬────────┘       │
│           │                      │                      │                 │
│           ▼                      ▼                      ▼                 │
│  ┌──────────────────────────────────────────────────────────────────┐    │
│  │                        Jenkins Pipeline                           │    │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐          │    │
│  │  │  Build   │  │   Test   │  │  Quality │  │  Deploy  │          │    │
│  │  │  Stage   │  │  Stage   │  │   Gate   │  │  Stage   │          │    │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────┘          │    │
│  └──────────────────────────────────────────────────────────────────┘    │
│                                                                           │
│  ┌───────────────────────────────────────────────────────────────────┐   │
│  │                    Fichiers de configuration                       │   │
│  │  .pipeline/config.yml    Jenkinsfile    .pipeline/extensions/     │   │
│  └───────────────────────────────────────────────────────────────────┘   │
│                                                                           │
└──────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                    Étapes de Pipeline ABAP Cloud                         │
│                                                                          │
│  1. Init          2. Build         3. Test          4. Deploy           │
│  ┌─────────┐      ┌─────────┐      ┌─────────┐      ┌─────────┐        │
│  │ Checkout│      │ Pull    │      │ ATC     │      │ Release │        │
│  │ Config  │─────▶│ gCTS    │─────▶│ Unit    │─────▶│ Transport│       │
│  │ Setup   │      │ Activate│      │ Quality │      │ Import  │        │
│  └─────────┘      └─────────┘      └─────────┘      └─────────┘        │
│       │                │                │                │              │
│       ▼                ▼                ▼                ▼              │
│   Credentials      Syntax OK       Tests Pass       Deployed           │
│   chargées         Code activé    Qualité OK       vers cible         │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

@Library('piper-lib-os') _

abapEnvironmentPipeline script: this

@Library('piper-lib-os') _

pipeline {
    agent any

    options {
        timeout(time: 2, unit: 'HOURS')
        timestamps()
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }

    stages {
        stage('Init') {
            steps {
                abapEnvironmentPipelineStageInit script: this
            }
        }

        stage('Pull') {
            steps {
                abapEnvironmentPull script: this
            }
        }

        stage('ATC Check') {
            steps {
                abapEnvironmentRunATCCheck script: this
            }
        }

        stage('Unit Tests') {
            steps {
                abapEnvironmentRunAUnitTest script: this
            }
        }

        stage('Quality Gate') {
            steps {
                script {
                    def atcResults = readJSON file: 'ATCResults.json"
                    def unitResults = readJSON file: 'AUnitResults.json"

                    // Vérifier les résultats ATC
                    if (atcResults.findings.any { it.priority == '1' }) {
                        error "ATC: Findings critiques trouvés"
                    }

                    // Vérifier la couverture des tests unitaires
                    if (unitResults.coverage < 80) {
                        unstable "Couverture de code inférieure à 80%"
                    }
                }
            }
        }

        stage('Deploy') {
            when {
                branch 'main"
            }
            steps {
                abapEnvironmentAssemblePackages script: this
                // Release et import du transport
            }
        }
    }

    post {
        always {
            // Nettoyage et notifications
            cleanWs()
        }
        failure {
            mail to: '[email protected]',
                 subject: "Pipeline Failed: ${currentBuild.fullDisplayName}",
                 body: "Check: ${env.BUILD_URL}"
        }
    }
}

general:
  projectName: 'Z_MY_RAP_APP"
  sapPlatform: 'ABAP Environment"

stages:
  Init:
    stepConditions:
      abapEnvironmentPipelineStageInit:
        configKeys:
          - 'cloudFoundry/apiEndpoint"
          - 'cloudFoundry/org"
          - 'cloudFoundry/space"

steps:
  # Configuration Cloud Foundry
  cloudFoundry:
    apiEndpoint: 'https://api.cf.eu10.hana.ondemand.com"
    org: 'my-org"
    space: 'dev"
    credentialsId: 'cf-credentials"

  # Configuration ABAP Environment
  abapEnvironmentPull:
    cfServiceInstance: 'my-abap-instance"
    repositoryName: 'z_my_rap_app"
    branchName: 'main"

  # Configuration ATC
  abapEnvironmentRunATCCheck:
    atcConfig:
      objectSet:
        type: 'component"
        component: 'Z_MY_RAP_APP"
      checkVariant: 'ABAP_CLOUD_DEVELOPMENT"
    generateHTML: true
    failOnSeverity: 'error"

  # Configuration des tests unitaires
  abapEnvironmentRunAUnitTest:
    aunitConfig:
      objectSet:
        type: 'component"
        component: 'Z_MY_RAP_APP"
      options:
        withCoverage: true
        coverageFormat: 'html"
    failOnFailure: true

  # Assemblage de package
  abapEnvironmentAssemblePackages:
    cfServiceInstance: 'my-abap-instance"
    packages:
      - name: 'Z_MY_RAP_APP"
        version: '1.0.0"

# Configuration ATC étendue
steps:
  abapEnvironmentRunATCCheck:
    atcConfig:
      objectSet:
        type: 'package"
        component: 'Z_MY_RAP_APP"

      # La variante de vérification définit les contrôles
      checkVariant: 'ABAP_CLOUD_DEVELOPMENT"

      # Filtres d'objets supplémentaires
      objectFilter:
        - type: 'CLAS"
          namePattern: 'ZCL_*"
        - type: 'TABL"
          namePattern: 'Z*"

    # Options de sortie
    generateHTML: true
    generateXML: true

    # Gestion des erreurs
    failOnSeverity: 'error'   # error, warning, ou info

    # Publier les findings ATC en tant que JUnit
    publishResults: true

stage('ATC Check') {
    steps {
        abapEnvironmentRunATCCheck script: this

        script {
            // Publier les résultats ATC en tant que JUnit
            junit allowEmptyResults: true, testResults: 'ATCResults.xml"

            // Archiver le rapport HTML
            publishHTML target: [
                allowMissing: false,
                alwaysLinkToLastBuild: true,
                keepAll: true,
                reportDir: '.',
                reportFiles: 'ATCResults.html',
                reportName: 'ATC Report"
            ]

            // Analyser les findings
            def atcJson = readJSON file: 'ATCResults.json"
            def criticalFindings = atcJson.findings.findAll { it.priority == '1' }

            if (criticalFindings.size() > 0) {
                currentBuild.result = 'FAILURE"
                error "ATC: ${criticalFindings.size()} findings critiques"
            }
        }
    }
}

steps:
  # Créer un transport et inclure les objets
  abapEnvironmentAssemblePackages:
    cfServiceInstance: 'my-abap-instance"
    packages:
      - name: 'Z_MY_RAP_APP"
        version: '${env.BUILD_NUMBER}"

  # Release du transport
  abapEnvironmentCreateSystemLocal:
    cfServiceInstance: 'my-abap-instance"
    transportDescription: 'CI/CD Release ${env.BUILD_NUMBER}"

  # Import dans le système cible
  abapEnvironmentImport:
    cfServiceInstance: 'my-abap-instance-prod"
    importOption: 'transport"

stage('Transport') {
    when {
        allOf {
            branch 'main"
            expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' }
        }
    }
    steps {
        script {
            // 1. Créer le transport
            def transportId = abapEnvironmentCreateSystemLocal(
                script: this,
                transportDescription: "Release ${env.BUILD_NUMBER}"
            )

            echo "Transport créé: ${transportId}"

            // 2. Inclure les objets
            abapEnvironmentAssemblePackages(
                script: this,
                transportId: transportId
            )

            // 3. Relâcher le transport
            abapEnvironmentReleaseTransport(
                script: this,
                transportId: transportId
            )

            // 4. Importer dans le système cible
            abapEnvironmentImport(
                script: this,
                transportId: transportId,
                targetSystem: 'PRD"
            )
        }
    }
}

steps:
  abapEnvironmentRunAUnitTest:
    aunitConfig:
      objectSet:
        type: 'package"
        component: 'Z_MY_RAP_APP"

      options:
        # Options de test
        measurementSystem: true
        coverageAnalyzer: true

        # Paramètres de couverture
        withCoverage: true
        coverageFormat: 'html"

        # Filtre de niveau de risque
        riskLevel: 'all'  # all, dangerous, critical

        # Filtre de durée
        duration: 'all'   # all, short, medium, long

    # Seuils
    coverageThreshold:
      statement: 80
      branch: 70
      procedure: 90

    failOnFailure: true
    failOnError: true

stage('Unit Tests') {
    steps {
        abapEnvironmentRunAUnitTest script: this

        script {
            // Publier les résultats JUnit
            junit allowEmptyResults: false,
                  testResults: 'AUnitResults.xml"

            // Rapport de couverture
            publishHTML target: [
                reportDir: 'coverage',
                reportFiles: 'index.html',
                reportName: 'Code Coverage"
            ]

            // Vérifier le seuil de couverture
            def coverage = readJSON file: 'coverage/summary.json"

            if (coverage.statements.pct < 80) {
                unstable "Couverture des instructions: ${coverage.statements.pct}% < 80%"
            }

            // Afficher les statistiques de test
            echo """
            Résultats des tests:
            - Total des tests: ${coverage.tests.total}
            - Réussis: ${coverage.tests.passed}
            - Échoués: ${coverage.tests.failed}
            - Couverture: ${coverage.statements.pct}%
            """
        }
    }
}

"! @testing Z_MY_CLASS
CLASS ltcl_my_class DEFINITION FINAL FOR TESTING
  DURATION SHORT
  RISK LEVEL HARMLESS.

  PRIVATE SECTION.
    CLASS-DATA: environment TYPE REF TO if_osql_test_environment.
    DATA: cut TYPE REF TO zcl_my_class.

    CLASS-METHODS: class_setup.
    CLASS-METHODS: class_teardown.
    METHODS: setup.
    METHODS: teardown.

    METHODS: test_happy_path FOR TESTING.
    METHODS: test_error_handling FOR TESTING.
ENDCLASS.

CLASS ltcl_my_class IMPLEMENTATION.
  METHOD class_setup.
    " Configurer l'environnement Test-Double
    environment = cl_osql_test_environment=>create(
      i_dependency_list = VALUE #( ( 'ZMYTABLE' ) ) ).
  ENDMETHOD.

  METHOD class_teardown.
    environment->destroy( ).
  ENDMETHOD.

  METHOD setup.
    cut = NEW zcl_my_class( ).
    environment->clear_doubles( ).
  ENDMETHOD.

  METHOD teardown.
    " Nettoyage
  ENDMETHOD.

  METHOD test_happy_path.
    " Given
    DATA(test_data) = VALUE zmytable( id = '001' name = 'Test' ).
    environment->insert_test_data( i_data = REF #( test_data ) ).

    " When
    DATA(result) = cut->process( '001' ).

    " Then
    cl_abap_unit_assert=>assert_equals(
      act = result-status
      exp = 'OK"
      msg = 'Le statut devrait être OK' ).
  ENDMETHOD.

  METHOD test_error_handling.
    " Given - pas de données de test

    " When/Then - exception attendue
    TRY.
        cut->process( 'INVALID' ).
        cl_abap_unit_assert=>fail( 'Exception attendue' ).
      CATCH zcx_my_exception INTO DATA(lx_error).
        cl_abap_unit_assert=>assert_bound( lx_error ).
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

steps:
  myCustomStep:
    abapEndpoint: 'https://my-abap-instance.abap.eu10.hana.ondemand.com"
    credentialsId: 'abap-credentials"

stages:
  Build:
    stepConditions:
      myCustomStep:
        configKeys:
          - 'abapEndpoint"

// Informations de débogage dans la pipeline
pipeline {
    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }

    stages {
        stage('Debug') {
            steps {
                script {
                    // Afficher les variables d'environnement
                    sh 'env | sort"

                    // Vérifier la version Piper
                    sh 'piper version"

                    // Valider la configuration
                    sh 'piper checkIfStepActive --step abapEnvironmentPull"
                }
            }
        }
    }
}