人工智慧驅動的軟體工程革新：從自動化測試到DevSecOps的完整實踐

import unittest
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, NoSuchElementException

class LoginFunctionalityTest(unittest.TestCase):
    """
    登入功能的自動化測試套件
    涵蓋正常登入、錯誤處理、以及安全性驗證
    """
    
    @classmethod
    def setUpClass(cls):
        """
        測試類別級別的初始化
        設定WebDriver選項與測試環境
        """
        chrome_options = webdriver.ChromeOptions()
        chrome_options.add_argument('--headless')  # 無頭模式,適合CI環境
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        cls.base_url = "https://example.com"
    
    def setUp(self):
        """
        每個測試案例執行前的準備工作
        初始化WebDriver並導航至測試頁面
        """
        self.driver = webdriver.Chrome(options=self.chrome_options)
        self.driver.implicitly_wait(10)  # 設定隱式等待
        self.driver.get(f"{self.base_url}/login")
        self.wait = WebDriverWait(self.driver, 15)
    
    def test_valid_login_success(self):
        """
        測試案例: 使用有效憑證進行登入
        預期結果: 成功登入並導向使用者儀表板
        """
        try:
            # 等待登入表單完全載入
            username_field = self.wait.until(
                EC.presence_of_element_located((By.ID, "username"))
            )
            password_field = self.driver.find_element(By.ID, "password")
            submit_button = self.driver.find_element(By.ID, "login-submit")
            
            # 輸入有效的測試憑證
            username_field.send_keys("[email protected]")
            password_field.send_keys("SecureP@ssw0rd")
            
            # 提交登入表單
            submit_button.click()
            
            # 等待頁面跳轉並驗證登入成功
            dashboard = self.wait.until(
                EC.presence_of_element_located((By.CLASS_NAME, "dashboard-container"))
            )
            
            # 驗證使用者資訊顯示正確
            user_greeting = self.driver.find_element(By.CLASS_NAME, "user-greeting")
            self.assertIn("歡迎回來", user_greeting.text)
            
            # 驗證登入後URL變更
            self.assertIn("/dashboard", self.driver.current_url)
            
        except TimeoutException:
            self.fail("登入流程逾時,頁面元素未能在預期時間內載入")
        except NoSuchElementException as e:
            self.fail(f"找不到必要的頁面元素: {str(e)}")
    
    def test_invalid_credentials_error(self):
        """
        測試案例: 使用無效憑證嘗試登入
        預期結果: 顯示錯誤訊息且不允許登入
        """
        username_field = self.driver.find_element(By.ID, "username")
        password_field = self.driver.find_element(By.ID, "password")
        submit_button = self.driver.find_element(By.ID, "login-submit")
        
        # 輸入錯誤的憑證
        username_field.send_keys("[email protected]")
        password_field.send_keys("WrongPassword")
        submit_button.click()
        
        # 驗證錯誤訊息顯示
        error_message = self.wait.until(
            EC.visibility_of_element_located((By.CLASS_NAME, "error-message"))
        )
        self.assertIn("帳號或密碼錯誤", error_message.text)
        
        # 確認仍停留在登入頁面
        self.assertIn("/login", self.driver.current_url)
    
    def test_empty_fields_validation(self):
        """
        測試案例: 空白欄位的前端驗證
        預期結果: 顯示欄位必填提示
        """
        submit_button = self.driver.find_element(By.ID, "login-submit")
        submit_button.click()
        
        # 驗證HTML5表單驗證觸發
        username_field = self.driver.find_element(By.ID, "username")
        validation_message = username_field.get_attribute("validationMessage")
        self.assertIsNotNone(validation_message)
        self.assertNotEqual(validation_message, "")
    
    def test_sql_injection_prevention(self):
        """
        測試案例: SQL注入攻擊防護
        預期結果: 系統安全處理惡意輸入
        """
        username_field = self.driver.find_element(By.ID, "username")
        password_field = self.driver.find_element(By.ID, "password")
        
        # 嘗試SQL注入攻擊模式
        malicious_input = "admin' OR '1'='1"
        username_field.send_keys(malicious_input)
        password_field.send_keys("anything")
        
        submit_button = self.driver.find_element(By.ID, "login-submit")
        submit_button.click()
        
        # 確認攻擊未成功
        time.sleep(2)
        self.assertIn("/login", self.driver.current_url)
    
    def test_remember_me_functionality(self):
        """
        測試案例: 記住我功能
        預期結果: Cookie正確設定並在重新開啟時保持登入狀態
        """
        username_field = self.driver.find_element(By.ID, "username")
        password_field = self.driver.find_element(By.ID, "password")
        remember_checkbox = self.driver.find_element(By.ID, "remember-me")
        
        username_field.send_keys("[email protected]")
        password_field.send_keys("SecureP@ssw0rd")
        remember_checkbox.click()
        
        submit_button = self.driver.find_element(By.ID, "login-submit")
        submit_button.click()
        
        # 等待登入完成
        self.wait.until(EC.url_contains("/dashboard"))
        
        # 驗證認證Cookie存在且設定了適當的過期時間
        auth_cookie = self.driver.get_cookie("auth_token")
        self.assertIsNotNone(auth_cookie)
        
        # 關閉並重新開啟瀏覽器
        self.driver.quit()
        self.setUp()
        self.driver.get(f"{self.base_url}/dashboard")
        
        # 驗證仍保持登入狀態
        time.sleep(2)
        self.assertIn("/dashboard", self.driver.current_url)
    
    def tearDown(self):
        """
        每個測試案例執行後的清理工作
        截圖保存與WebDriver關閉
        """
        if hasattr(self, '_outcome'):
            result = self.defaultTestResult()
            self._feedErrorsToResult(result, self._outcome.errors)
            
            # 如果測試失敗,保存截圖以便除錯
            if result.failures or result.errors:
                timestamp = time.strftime("%Y%m%d-%H%M%S")
                screenshot_name = f"failure_{self._testMethodName}_{timestamp}.png"
                self.driver.save_screenshot(f"test_reports/{screenshot_name}")
        
        self.driver.quit()
    
    @classmethod
    def tearDownClass(cls):
        """
        測試類別級別的清理工作
        """
        pass

if __name__ == "__main__":
    # 建立測試套件
    test_suite = unittest.TestLoader().loadTestsFromTestCase(LoginFunctionalityTest)
    
    # 執行測試並生成詳細報告
    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(test_suite)
    
    # 根據測試結果設定退出代碼
    exit(0 if result.wasSuccessful() else 1)

// .eslintrc.js - 企業級ESLint配置範例
module.exports = {
  // 指定程式碼執行環境
  env: {
    browser: true,   // 瀏覽器全域變數
    node: true,      // Node.js全域變數與作用域
    es2022: true,    // 啟用ES2022語法
    jest: true       // Jest測試框架全域變數
  },
  
  // 繼承推薦的規則集
  extends: [
    'eslint:recommended',           // ESLint核心推薦規則
    'plugin:security/recommended',  // 安全性檢查規則
    'plugin:promise/recommended',   // Promise最佳實踐
    'plugin:import/recommended',    // 匯入語句檢查
    'plugin:node/recommended',      // Node.js最佳實踐
    'airbnb-base',                  // Airbnb風格指南
    'prettier'                      // 與Prettier整合
  ],
  
  // 語法解析器選項
  parserOptions: {
    ecmaVersion: 2022,              // 支援最新ECMAScript特性
    sourceType: 'module',           // 使用ES6模組
    ecmaFeatures: {
      impliedStrict: true           // 全域嚴格模式
    }
  },
  
  // 使用的外掛
  plugins: [
    'security',        // 安全性檢查
    'promise',         // Promise相關檢查
    'import',          // 匯入語句檢查
    'node',            // Node.js特定檢查
    'jsdoc'            // JSDoc註解檢查
  ],
  
  // 自訂規則配置
  rules: {
    // ===== 錯誤防範規則 =====
    
    // 禁止使用console,但允許warn與error
    'no-console': ['warn', { 
      allow: ['warn', 'error', 'info'] 
    }],
    
    // 禁止未使用的變數,但允許以底線開頭的變數
    'no-unused-vars': ['error', {
      vars: 'all',
      args: 'after-used',
      argsIgnorePattern: '^_',
      varsIgnorePattern: '^_'
    }],
    
    // 要求使用const或let,禁止var
    'no-var': 'error',
    'prefer-const': ['error', {
      destructuring: 'all',
      ignoreReadBeforeAssign: false
    }],
    
    // 禁止修改const宣告的變數
    'no-const-assign': 'error',
    
    // 要求箭頭函數的參數使用括號
    'arrow-parens': ['error', 'always'],
    
    // 要求使用模板字串而非字串拼接
    'prefer-template': 'error',
    
    // ===== 安全性規則 =====
    
    // 禁止使用eval
    'no-eval': 'error',
    
    // 禁止使用with語句
    'no-with': 'error',
    
    // 禁止不必要的字串拼接
    'no-useless-concat': 'error',
    
    // 要求使用isNaN()檢查NaN
    'use-isnan': 'error',
    
    // 禁止在正規表達式中使用控制字元
    'no-control-regex': 'error',
    
    // 偵測可能的SQL注入
    'security/detect-sql-injection': 'error',
    
    // 偵測不安全的正規表達式
    'security/detect-unsafe-regex': 'error',
    
    // 偵測非字面量的require
    'security/detect-non-literal-require': 'warn',
    
    // ===== Promise相關規則 =====
    
    // 要求Promise catch處理
    'promise/catch-or-return': 'error',
    
    // 避免Promise內部巢狀
    'promise/no-nesting': 'warn',
    
    // 要求在Promise中return
    'promise/always-return': 'error',
    
    // 避免在Promise中使用async/await
    'promise/no-native': 'off',
    
    // ===== 程式碼品質規則 =====
    
    // 要求函數複雜度不超過15
    'complexity': ['warn', { max: 15 }],
    
    // 要求函數最大長度不超過100行
    'max-lines-per-function': ['warn', {
      max: 100,
      skipBlankLines: true,
      skipComments: true
    }],
    
    // 要求檔案最大長度不超過500行
    'max-lines': ['warn', {
      max: 500,
      skipBlankLines: true,
      skipComments: true
    }],
    
    // 限制函數參數數量
    'max-params': ['warn', { max: 5 }],
    
    // 限制巢狀深度
    'max-depth': ['warn', { max: 4 }],
    
    // ===== 匯入語句規則 =====
    
    // 要求匯入語句排序
    'import/order': ['error', {
      groups: [
        'builtin',    // Node.js內建模組
        'external',   // 外部依賴
        'internal',   // 內部模組
        'parent',     // 父層目錄
        'sibling',    // 同層目錄
        'index'       // 當前目錄index
      ],
      'newlines-between': 'always',
      alphabetize: {
        order: 'asc',
        caseInsensitive: true
      }
    }],
    
    // 禁止重複匯入
    'import/no-duplicates': 'error',
    
    // 禁止匯入開發依賴
    'import/no-extraneous-dependencies': ['error', {
      devDependencies: [
        '**/*.test.js',
        '**/*.spec.js',
        '**/test/**'
      ]
    }],
    
    // ===== JSDoc註解規則 =====
    
    // 要求函數有JSDoc註解
    'jsdoc/require-jsdoc': ['warn', {
      require: {
        FunctionDeclaration: true,
        MethodDefinition: true,
        ClassDeclaration: true
      }
    }],
    
    // 要求參數描述
    'jsdoc/require-param-description': 'warn',
    
    // 要求返回值描述
    'jsdoc/require-returns-description': 'warn',
    
    // 檢查參數名稱是否匹配
    'jsdoc/check-param-names': 'error'
  },
  
  // 針對特定檔案的覆蓋規則
  overrides: [
    {
      // 測試檔案的特殊規則
      files: ['**/*.test.js', '**/*.spec.js'],
      env: {
        jest: true
      },
      rules: {
        'max-lines-per-function': 'off',
        'max-lines': 'off'
      }
    },
    {
      // 配置檔案的特殊規則
      files: ['*.config.js', '.eslintrc.js'],
      rules: {
        'no-console': 'off',
        'import/no-extraneous-dependencies': 'off'
      }
    }
  ],
  
  // 全域變數宣告
  globals: {
    process: 'readonly',
    __dirname: 'readonly',
    __filename: 'readonly'
  },
  
  // 忽略特定檔案或目錄
  ignorePatterns: [
    'node_modules/',
    'dist/',
    'build/',
    'coverage/',
    '*.min.js'
  ]
};

// Jenkinsfile - 企業級CI/CD流水線定義
@Library('shared-pipeline-library') _

pipeline {
    // 指定執行代理,使用Docker容器隔離執行環境
    agent {
        docker {
            image 'node:18-alpine'
            args '-v /var/run/docker.sock:/var/run/docker.sock'
        }
    }
    
    // 環境變數定義
    environment {
        // 應用程式資訊
        APP_NAME = 'web-application'
        APP_VERSION = "${env.BUILD_NUMBER}"
        
        // Docker Registry資訊
        DOCKER_REGISTRY = 'registry.example.com'
        DOCKER_IMAGE = "${DOCKER_REGISTRY}/${APP_NAME}"
        
        // 部署環境資訊
        DEV_SERVER = 'dev.example.com'
        STAGING_SERVER = 'staging.example.com'
        PROD_SERVER = 'prod.example.com'
        
        // 通知設定
        SLACK_CHANNEL = '#ci-cd-notifications'
        EMAIL_RECIPIENTS = '[email protected]'
        
        // 品質閘門閾值
        CODE_COVERAGE_THRESHOLD = '80'
        SECURITY_SCAN_THRESHOLD = 'medium'
    }
    
    // 流水線選項
    options {
        // 保留最近30次建置
        buildDiscarder(logRotator(numToKeepStr: '30'))
        
        // 設定建置逾時為1小時
        timeout(time: 1, unit: 'HOURS')
        
        // 禁止並行執行
        disableConcurrentBuilds()
        
        // 啟用時間戳記
        timestamps()
        
        // 啟用顏色輸出
        ansiColor('xterm')
    }
    
    // 流水線階段定義
    stages {
        
        // 階段1: 程式碼檢出與環境準備
        stage('Checkout & Setup') {
            steps {
                script {
                    // 檢出程式碼
                    checkout scm
                    
                    // 顯示建置資訊
                    echo "Building ${APP_NAME} version ${APP_VERSION}"
                    echo "Branch: ${env.GIT_BRANCH}"
                    echo "Commit: ${env.GIT_COMMIT}"
                    
                    // 安裝依賴
                    sh 'npm ci --prefer-offline --no-audit'
                }
            }
        }
        
        // 階段2: 程式碼品質檢查
        stage('Code Quality') {
            parallel {
                // 子階段: 程式碼風格檢查
                stage('Linting') {
                    steps {
                        script {
                            echo '執行ESLint程式碼檢查...'
                            sh 'npm run lint -- --format json --output-file eslint-report.json || true'
                            
                            // 解析ESLint報告
                            def lintReport = readJSON file: 'eslint-report.json'
                            def errorCount = lintReport.collect { it.errorCount }.sum()
                            def warningCount = lintReport.collect { it.warningCount }.sum()
                            
                            echo "ESLint結果: ${errorCount}個錯誤, ${warningCount}個警告"
                            
                            // 如果有錯誤,標記為不穩定
                            if (errorCount > 0) {
                                currentBuild.result = 'UNSTABLE'
                                error("程式碼檢查發現 ${errorCount} 個錯誤")
                            }
                        }
                    }
                }
                
                // 子階段: 程式碼複雜度分析
                stage('Complexity Analysis') {
                    steps {
                        script {
                            echo '執行程式碼複雜度分析...'
                            sh 'npm run complexity || true'
                        }
                    }
                }
                
                // 子階段: 程式碼重複偵測
                stage('Duplication Detection') {
                    steps {
                        script {
                            echo '偵測程式碼重複...'
                            sh 'npm run jscpd || true'
                        }
                    }
                }
            }
        }
        
        // 階段3: 安全性掃描
        stage('Security Scan') {
            parallel {
                // 子階段: 依賴漏洞掃描
                stage('Dependency Scan') {
                    steps {
                        script {
                            echo '掃描依賴套件漏洞...'
                            sh 'npm audit --json > npm-audit.json || true'
                            
                            // 解析漏洞報告
                            def auditReport = readJSON file: 'npm-audit.json'
                            def criticalVulns = auditReport.metadata.vulnerabilities.critical ?: 0
                            def highVulns = auditReport.metadata.vulnerabilities.high ?: 0
                            
                            echo "發現 ${criticalVulns} 個嚴重漏洞, ${highVulns} 個高風險漏洞"
                            
                            // 嚴重漏洞導致建置失敗
                            if (criticalVulns > 0) {
                                error("發現 ${criticalVulns} 個嚴重安全漏洞,必須修復")
                            }
                        }
                    }
                }
                
                // 子階段: 靜態應用安全測試
                stage('SAST') {
                    steps {
                        script {
                            echo '執行靜態安全分析...'
                            sh 'npm run security-scan || true'
                        }
                    }
                }
            }
        }
        
        // 階段4: 單元測試與整合測試
        stage('Testing') {
            steps {
                script {
                    echo '執行測試套件...'
                    
                    // 執行測試並生成覆蓋率報告
                    sh '''
                        npm run test:unit -- --coverage --coverageReporters=json --coverageReporters=lcov
                        npm run test:integration
                    '''
                    
                    // 發佈測試報告
                    junit 'test-reports/**/*.xml'
                    
                    // 發佈覆蓋率報告
                    publishCoverage adapters: [istanbulCoberturaAdapter('coverage/cobertura-coverage.xml')], 
                                   sourceFileResolver: sourceFiles('STORE_ALL_BUILD')
                    
                    // 檢查覆蓋率閾值
                    def coverageReport = readJSON file: 'coverage/coverage-summary.json'
                    def totalCoverage = coverageReport.total.lines.pct
                    
                    echo "測試覆蓋率: ${totalCoverage}%"
                    
                    if (totalCoverage < CODE_COVERAGE_THRESHOLD.toInteger()) {
                        currentBuild.result = 'UNSTABLE'
                        echo "警告: 測試覆蓋率 ${totalCoverage}% 低於閾值 ${CODE_COVERAGE_THRESHOLD}%"
                    }
                }
            }
        }
        
        // 階段5: 應用程式建置
        stage('Build') {
            steps {
                script {
                    echo '建置應用程式...'
                    
                    // 執行生產建置
                    sh 'npm run build:prod'
                    
                    // 驗證建置產物
                    sh 'test -d dist || exit 1'
                    
                    // 壓縮建置產物
                    sh "tar -czf ${APP_NAME}-${APP_VERSION}.tar.gz -C dist ."
                    
                    // 封存建置產物
                    archiveArtifacts artifacts: "${APP_NAME}-${APP_VERSION}.tar.gz", 
                                    fingerprint: true
                }
            }
        }
        
        // 階段6: Docker映像建置
        stage('Docker Build') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    branch 'release/*'
                }
            }
            steps {
                script {
                    echo '建置Docker映像...'
                    
                    // 建置多架構映像
                    sh """
                        docker buildx build \
                            --platform linux/amd64,linux/arm64 \
                            --tag ${DOCKER_IMAGE}:${APP_VERSION} \
                            --tag ${DOCKER_IMAGE}:latest \
                            --build-arg APP_VERSION=${APP_VERSION} \
                            --build-arg BUILD_DATE=\$(date -u +'%Y-%m-%dT%H:%M:%SZ') \
                            --build-arg VCS_REF=${env.GIT_COMMIT} \
                            --push \
                            .
                    """
                    
                    // 掃描映像安全性
                    sh """
                        trivy image --severity CRITICAL,HIGH \
                             --format json --output trivy-report.json \
                             ${DOCKER_IMAGE}:${APP_VERSION}
                    """
                }
            }
        }
        
        // 階段7: 部署到開發環境
        stage('Deploy to Dev') {
            when {
                branch 'develop'
            }
            steps {
                script {
                    echo '部署到開發環境...'
                    
                    deployToEnvironment(
                        server: DEV_SERVER,
                        image: "${DOCKER_IMAGE}:${APP_VERSION}",
                        environment: 'development'
                    )
                    
                    // 執行冒煙測試
                    sh "curl -f https://${DEV_SERVER}/health || exit 1"
                }
            }
        }
        
        // 階段8: 部署到預備環境
        stage('Deploy to Staging') {
            when {
                anyOf {
                    branch 'main'
                    branch 'release/*'
                }
            }
            steps {
                script {
                    echo '部署到預備環境...'
                    
                    deployToEnvironment(
                        server: STAGING_SERVER,
                        image: "${DOCKER_IMAGE}:${APP_VERSION}",
                        environment: 'staging'
                    )
                    
                    // 執行端對端測試
                    sh "npm run test:e2e -- --base-url=https://${STAGING_SERVER}"
                }
            }
        }
        
        // 階段9: 部署到生產環境
        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                script {
                    // 人工確認步驟
                    timeout(time: 24, unit: 'HOURS') {
                        input message: '確認部署到生產環境?', 
                              ok: '部署',
                              submitter: 'prod-deploy-team'
                    }
                    
                    echo '部署到生產環境...'
                    
                    // 藍綠部署策略
                    deployToEnvironment(
                        server: PROD_SERVER,
                        image: "${DOCKER_IMAGE}:${APP_VERSION}",
                        environment: 'production',
                        strategy: 'blue-green'
                    )
                    
                    // 驗證部署
                    sh "curl -f https://${PROD_SERVER}/health || exit 1"
                    
                    // 標記Git版本
                    sh "git tag -a v${APP_VERSION} -m 'Release version ${APP_VERSION}'"
                    sh "git push origin v${APP_VERSION}"
                }
            }
        }
    }
    
    // 後處理階段
    post {
        always {
            // 清理工作空間
            script {
                echo '清理建置環境...'
                
                // 發佈測試報告
                publishHTML([
                    allowMissing: false,
                    alwaysLinkToLastBuild: true,
                    keepAll: true,
                    reportDir: 'test-reports',
                    reportFiles: 'index.html',
                    reportName: '測試報告'
                ])
                
                // 發佈覆蓋率報告
                publishHTML([
                    allowMissing: false,
                    alwaysLinkToLastBuild: true,
                    keepAll: true,
                    reportDir: 'coverage/lcov-report',
                    reportFiles: 'index.html',
                    reportName: '覆蓋率報告'
                ])
            }
        }
        
        success {
            script {
                echo '流水線執行成功!'
                
                // 發送成功通知
                slackSend(
                    color: 'good',
                    channel: SLACK_CHANNEL,
                    message: """
                        ✅ 建置成功
                        專案: ${APP_NAME}
                        版本: ${APP_VERSION}
                        分支: ${env.GIT_BRANCH}
                        建置時間: ${currentBuild.durationString}
                        查看: ${env.BUILD_URL}
                    """
                )
            }
        }
        
        failure {
            script {
                echo '流水線執行失敗!'
                
                // 發送失敗通知
                slackSend(
                    color: 'danger',
                    channel: SLACK_CHANNEL,
                    message: """
                        ❌ 建置失敗
                        專案: ${APP_NAME}
                        版本: ${APP_VERSION}
                        分支: ${env.GIT_BRANCH}
                        失敗階段: ${env.STAGE_NAME}
                        查看日誌: ${env.BUILD_URL}console
                    """
                )
                
                // 發送郵件通知
                emailext(
                    subject: "[Jenkins] ${APP_NAME} 建置失敗 #${env.BUILD_NUMBER}",
                    body: """
                        <h2>建置失敗通知</h2>
                        <p>專案: ${APP_NAME}</p>
                        <p>分支: ${env.GIT_BRANCH}</p>
                        <p>失敗階段: ${env.STAGE_NAME}</p>
                        <p><a href="${env.BUILD_URL}">查看建置詳情</a></p>
                    """,
                    to: EMAIL_RECIPIENTS,
                    mimeType: 'text/html'
                )
            }
        }
        
        unstable {
            script {
                echo '流水線執行不穩定'
                
                slackSend(
                    color: 'warning',
                    channel: SLACK_CHANNEL,
                    message: """
                        ⚠️ 建置不穩定
                        專案: ${APP_NAME}
                        版本: ${APP_VERSION}
                        分支: ${env.GIT_BRANCH}
                        警告: 存在品質問題需要關注
                        查看: ${env.BUILD_URL}
                    """
                )
            }
        }
    }
}

// 自訂部署函數
def deployToEnvironment(Map config) {
    echo "部署 ${config.image} 到 ${config.environment} 環境"
    
    // 使用Ansible進行部署
    ansiblePlaybook(
        playbook: 'deploy/ansible/deploy.yml',
        inventory: "deploy/ansible/inventory/${config.environment}",
        extras: "-e image=${config.image} -e server=${config.server}",
        colorized: true
    )
    
    // 等待服務就緒
    sleep(time: 30, unit: 'SECONDS')
}