人工智慧驅動軟體開發：從自動化測試到智慧程式碼審查的完整實踐指南

# 機器學習程式碼品質預測系統實作
# 使用Random Forest演算法建立程式碼缺陷預測模型

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np
import joblib

class CodeQualityPredictor:
    """
    程式碼品質預測器
    負責訓練與執行程式碼缺陷預測模型
    """
    
    def __init__(self, n_estimators=100, random_state=42):
        """
        初始化預測器
        
        參數:
            n_estimators: Random Forest中決策樹的數量
            random_state: 隨機種子，確保實驗可重現性
        """
        self.model = RandomForestClassifier(
            n_estimators=n_estimators,
            max_depth=20,
            min_samples_split=5,
            min_samples_leaf=2,
            random_state=random_state,
            n_jobs=-1  # 使用所有CPU核心進行平行運算
        )
        self.scaler = StandardScaler()  # 特徵標準化工具
        self.feature_importance = None  # 儲存特徵重要性分析結果
        
    def load_dataset(self, csv_path):
        """
        載入程式碼特徵資料集
        
        參數:
            csv_path: CSV檔案路徑，包含程式碼特徵與缺陷標籤
            
        回傳:
            X: 特徵矩陣
            y: 標籤向量
        """
        # 讀取程式碼特徵資料
        # 資料集應包含以下欄位:
        # - complexity: 循環複雜度
        # - lines_of_code: 程式碼行數
        # - comment_ratio: 註解比例
        # - duplication_ratio: 程式碼重複率
        # - test_coverage: 測試覆蓋率
        # - change_frequency: 修改頻率
        # - has_error: 是否存在缺陷（標籤）
        data = pd.read_csv(csv_path)
        
        # 處理遺失值：使用中位數填充數值型特徵
        numeric_columns = data.select_dtypes(include=[np.number]).columns
        data[numeric_columns] = data[numeric_columns].fillna(
            data[numeric_columns].median()
        )
        
        # 分離特徵與標籤
        X = data.drop('has_error', axis=1)
        y = data['has_error']
        
        return X, y
    
    def train(self, X_train, y_train):
        """
        訓練程式碼缺陷預測模型
        
        參數:
            X_train: 訓練集特徵
            y_train: 訓練集標籤
        """
        # 特徵標準化：將所有特徵縮放到相同尺度
        X_train_scaled = self.scaler.fit_transform(X_train)
        
        # 訓練Random Forest模型
        print("開始訓練程式碼品質預測模型...")
        self.model.fit(X_train_scaled, y_train)
        
        # 執行5折交叉驗證評估模型穩定性
        cv_scores = cross_val_score(
            self.model, X_train_scaled, y_train, 
            cv=5, scoring='f1'
        )
        print(f"交叉驗證F1分數: {cv_scores.mean():.4f} (+/- {cv_scores.std():.4f})")
        
        # 儲存特徵重要性分析結果
        self.feature_importance = pd.DataFrame({
            'feature': X_train.columns,
            'importance': self.model.feature_importances_
        }).sort_values('importance', ascending=False)
        
        print("\n特徵重要性排名:")
        print(self.feature_importance)
        
    def predict(self, X_test):
        """
        預測程式碼是否存在缺陷
        
        參數:
            X_test: 待預測的程式碼特徵
            
        回傳:
            predictions: 預測結果（0:無缺陷, 1:有缺陷）
            probabilities: 缺陷機率
        """
        # 特徵標準化
        X_test_scaled = self.scaler.transform(X_test)
        
        # 執行預測
        predictions = self.model.predict(X_test_scaled)
        probabilities = self.model.predict_proba(X_test_scaled)[:, 1]
        
        return predictions, probabilities
    
    def evaluate(self, X_test, y_test):
        """
        評估模型效能
        
        參數:
            X_test: 測試集特徵
            y_test: 測試集真實標籤
        """
        predictions, probabilities = self.predict(X_test)
        
        # 輸出詳細分類報告
        print("\n模型效能評估:")
        print(classification_report(
            y_test, predictions,
            target_names=['正常程式碼', '問題程式碼']
        ))
        
        # 混淆矩陣分析
        cm = confusion_matrix(y_test, predictions)
        print("\n混淆矩陣:")
        print(f"真負例: {cm[0][0]}, 假正例: {cm[0][1]}")
        print(f"假負例: {cm[1][0]}, 真正例: {cm[1][1]}")
        
        # 計算並輸出關鍵指標
        accuracy = (cm[0][0] + cm[1][1]) / cm.sum()
        precision = cm[1][1] / (cm[1][1] + cm[0][1]) if (cm[1][1] + cm[0][1]) > 0 else 0
        recall = cm[1][1] / (cm[1][1] + cm[1][0]) if (cm[1][1] + cm[1][0]) > 0 else 0
        
        print(f"\n準確率: {accuracy:.4f}")
        print(f"精確率: {precision:.4f}")
        print(f"召回率: {recall:.4f}")
        
    def save_model(self, model_path='code_quality_model.pkl'):
        """
        儲存訓練完成的模型
        
        參數:
            model_path: 模型儲存路徑
        """
        joblib.dump({
            'model': self.model,
            'scaler': self.scaler,
            'feature_importance': self.feature_importance
        }, model_path)
        print(f"\n模型已儲存至: {model_path}")
    
    @classmethod
    def load_model(cls, model_path='code_quality_model.pkl'):
        """
        載入已訓練的模型
        
        參數:
            model_path: 模型檔案路徑
            
        回傳:
            predictor: 已載入模型的預測器實例
        """
        saved_data = joblib.load(model_path)
        predictor = cls()
        predictor.model = saved_data['model']
        predictor.scaler = saved_data['scaler']
        predictor.feature_importance = saved_data['feature_importance']
        return predictor

# 主程式執行範例
if __name__ == "__main__":
    # 初始化預測器
    predictor = CodeQualityPredictor(n_estimators=200)
    
    # 載入訓練資料
    X, y = predictor.load_dataset('code_features_dataset.csv')
    
    # 分割訓練集與測試集（80%訓練，20%測試）
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=42, stratify=y
    )
    
    print(f"訓練集大小: {len(X_train)}")
    print(f"測試集大小: {len(X_test)}")
    print(f"缺陷樣本比例: {y_train.mean():.2%}")
    
    # 訓練模型
    predictor.train(X_train, y_train)
    
    # 評估模型效能
    predictor.evaluate(X_test, y_test)
    
    # 儲存模型供後續使用
    predictor.save_model('production_code_quality_model.pkl')
    
    # 範例：對新程式碼進行預測
    new_code_features = pd.DataFrame({
        'complexity': [15],
        'lines_of_code': [350],
        'comment_ratio': [0.12],
        'duplication_ratio': [0.05],
        'test_coverage': [0.75],
        'change_frequency': [8]
    })
    
    predictions, probabilities = predictor.predict(new_code_features)
    print(f"\n新程式碼缺陷預測:")
    print(f"預測結果: {'存在缺陷風險' if predictions[0] == 1 else '品質良好'}")
    print(f"缺陷機率: {probabilities[0]:.2%}")

# AI驅動的Web應用自動化測試框架
# 整合Selenium與機器學習實現智慧元素定位與測試案例生成

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
from selenium.webdriver.chrome.options import Options
import logging
import time
import json
from datetime import datetime

class SmartWebTester:
    """
    智慧Web應用測試框架
    結合AI技術實現自適應元素定位與自動化測試案例執行
    """
    
    def __init__(self, headless=False, timeout=10):
        """
        初始化測試框架
        
        參數:
            headless: 是否使用無頭模式（不顯示瀏覽器視窗）
            timeout: 元素等待逾時時間（秒）
        """
        # 設定Chrome瀏覽器選項
        chrome_options = Options()
        if headless:
            chrome_options.add_argument('--headless')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--disable-gpu')
        
        # 初始化WebDriver
        self.driver = webdriver.Chrome(options=chrome_options)
        self.driver.maximize_window()
        self.wait = WebDriverWait(self.driver, timeout)
        
        # 初始化日誌系統
        self.logger = self._setup_logger()
        
        # 測試結果記錄
        self.test_results = []
        
    def _setup_logger(self):
        """
        設定測試日誌記錄器
        
        回傳:
            logger: 配置完成的日誌記錄器
        """
        logger = logging.getLogger('SmartWebTester')
        logger.setLevel(logging.INFO)
        
        # 建立檔案處理器：儲存詳細測試日誌
        file_handler = logging.FileHandler(
            f'test_log_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log',
            encoding='utf-8'
        )
        file_handler.setLevel(logging.DEBUG)
        
        # 建立控制台處理器：輸出重要訊息
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.INFO)
        
        # 設定日誌格式
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        
        logger.addHandler(file_handler)
        logger.addHandler(console_handler)
        
        return logger
    
    def smart_find_element(self, identifier, by_type=By.ID, alternative_strategies=None):
        """
        智慧元素定位功能
        嘗試多種策略定位網頁元素，提高測試腳本的穩定性
        
        參數:
            identifier: 元素識別符
            by_type: 主要定位策略
            alternative_strategies: 替代定位策略清單
            
        回傳:
            element: 定位到的網頁元素
        """
        # 嘗試主要定位策略
        try:
            element = self.wait.until(
                EC.presence_of_element_located((by_type, identifier))
            )
            self.logger.info(f"成功定位元素: {identifier} (使用 {by_type})")
            return element
        except TimeoutException:
            self.logger.warning(f"主要定位策略失敗: {identifier}")
        
        # 嘗試替代定位策略
        if alternative_strategies:
            for alt_by, alt_id in alternative_strategies:
                try:
                    element = self.wait.until(
                        EC.presence_of_element_located((alt_by, alt_id))
                    )
                    self.logger.info(
                        f"使用替代策略成功定位: {alt_id} (使用 {alt_by})"
                    )
                    return element
                except TimeoutException:
                    continue
        
        # 所有策略都失敗時，記錄錯誤並截圖
        self.logger.error(f"無法定位元素: {identifier}")
        self._capture_screenshot(f"element_not_found_{identifier}")
        raise NoSuchElementException(f"無法定位元素: {identifier}")
    
    def execute_test_scenario(self, scenario_config):
        """
        執行測試場景
        根據配置檔案執行一系列測試動作
        
        參數:
            scenario_config: 測試場景配置
        """
        scenario_name = scenario_config.get('name', 'Unnamed Scenario')
        self.logger.info(f"開始執行測試場景: {scenario_name}")
        
        test_result = {
            'scenario': scenario_name,
            'start_time': datetime.now().isoformat(),
            'steps': [],
            'status': 'PASS'
        }
        
        try:
            # 導航至測試網址
            url = scenario_config['url']
            self.driver.get(url)
            self.logger.info(f"載入測試頁面: {url}")
            time.sleep(2)  # 等待頁面完全載入
            
            # 執行測試步驟
            for step in scenario_config['steps']:
                step_result = self._execute_test_step(step)
                test_result['steps'].append(step_result)
                
                if not step_result['success']:
                    test_result['status'] = 'FAIL'
                    break
            
            # 驗證測試期望結果
            if 'assertions' in scenario_config:
                for assertion in scenario_config['assertions']:
                    assertion_result = self._verify_assertion(assertion)
                    test_result['steps'].append({
                        'type': 'assertion',
                        'description': assertion['description'],
                        'success': assertion_result
                    })
                    
                    if not assertion_result:
                        test_result['status'] = 'FAIL'
            
        except Exception as e:
            self.logger.error(f"測試場景執行失敗: {str(e)}")
            test_result['status'] = 'ERROR'
            test_result['error'] = str(e)
            self._capture_screenshot(f"error_{scenario_name}")
        
        finally:
            test_result['end_time'] = datetime.now().isoformat()
            self.test_results.append(test_result)
            self.logger.info(
                f"測試場景完成: {scenario_name} - 狀態: {test_result['status']}"
            )
        
        return test_result
    
    def _execute_test_step(self, step):
        """
        執行單一測試步驟
        
        參數:
            step: 測試步驟配置
            
        回傳:
            result: 步驟執行結果
        """
        action = step['action']
        description = step.get('description', action)
        
        self.logger.info(f"執行步驟: {description}")
        
        result = {
            'action': action,
            'description': description,
            'success': True,
            'message': ''
        }
        
        try:
            if action == 'click':
                # 點擊元素
                element = self.smart_find_element(
                    step['selector'],
                    by_type=getattr(By, step.get('by', 'ID')),
                    alternative_strategies=step.get('alternatives', [])
                )
                element.click()
                result['message'] = f"成功點擊元素: {step['selector']}"
                
            elif action == 'input':
                # 輸入文字
                element = self.smart_find_element(
                    step['selector'],
                    by_type=getattr(By, step.get('by', 'ID'))
                )
                element.clear()
                element.send_keys(step['value'])
                result['message'] = f"成功輸入內容至: {step['selector']}"
                
            elif action == 'wait':
                # 等待指定時間
                time.sleep(step['duration'])
                result['message'] = f"等待 {step['duration']} 秒"
                
            elif action == 'navigate':
                # 導航至指定URL
                self.driver.get(step['url'])
                result['message'] = f"導航至: {step['url']}"
            
            # 步驟執行後等待一小段時間確保DOM更新
            time.sleep(0.5)
            
        except Exception as e:
            result['success'] = False
            result['message'] = f"步驟執行失敗: {str(e)}"
            self.logger.error(result['message'])
            self._capture_screenshot(f"step_failed_{action}")
        
        return result
    
    def _verify_assertion(self, assertion):
        """
        驗證測試斷言
        
        參數:
            assertion: 斷言配置
            
        回傳:
            success: 驗證是否通過
        """
        try:
            assertion_type = assertion['type']
            
            if assertion_type == 'title':
                # 驗證頁面標題
                expected = assertion['expected']
                actual = self.driver.title
                success = expected in actual
                self.logger.info(
                    f"標題驗證: 預期='{expected}', 實際='{actual}', "
                    f"結果={'通過' if success else '失敗'}"
                )
                return success
                
            elif assertion_type == 'element_present':
                # 驗證元素是否存在
                self.smart_find_element(
                    assertion['selector'],
                    by_type=getattr(By, assertion.get('by', 'ID'))
                )
                self.logger.info(f"元素存在驗證通過: {assertion['selector']}")
                return True
                
            elif assertion_type == 'element_text':
                # 驗證元素文字內容
                element = self.smart_find_element(
                    assertion['selector'],
                    by_type=getattr(By, assertion.get('by', 'ID'))
                )
                expected = assertion['expected']
                actual = element.text
                success = expected in actual
                self.logger.info(
                    f"文字內容驗證: 預期包含'{expected}', 實際='{actual}', "
                    f"結果={'通過' if success else '失敗'}"
                )
                return success
                
        except Exception as e:
            self.logger.error(f"斷言驗證失敗: {str(e)}")
            return False
    
    def _capture_screenshot(self, filename):
        """
        擷取當前頁面截圖
        
        參數:
            filename: 截圖檔案名稱（不含副檔名）
        """
        try:
            filepath = f"screenshots/{filename}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
            self.driver.save_screenshot(filepath)
            self.logger.info(f"已儲存截圖: {filepath}")
        except Exception as e:
            self.logger.error(f"截圖失敗: {str(e)}")
    
    def generate_test_report(self, output_file='test_report.json'):
        """
        生成測試報告
        
        參數:
            output_file: 報告輸出檔案路徑
        """
        report = {
            'test_date': datetime.now().isoformat(),
            'total_scenarios': len(self.test_results),
            'passed': sum(1 for r in self.test_results if r['status'] == 'PASS'),
            'failed': sum(1 for r in self.test_results if r['status'] == 'FAIL'),
            'errors': sum(1 for r in self.test_results if r['status'] == 'ERROR'),
            'scenarios': self.test_results
        }
        
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        
        self.logger.info(f"測試報告已生成: {output_file}")
        self.logger.info(
            f"測試摘要 - 總計: {report['total_scenarios']}, "
            f"通過: {report['passed']}, "
            f"失敗: {report['failed']}, "
            f"錯誤: {report['errors']}"
        )
        
        return report
    
    def close(self):
        """關閉瀏覽器並清理資源"""
        self.driver.quit()
        self.logger.info("測試框架已關閉")

# 測試場景配置範例
test_scenarios = [
    {
        'name': '使用者登入流程測試',
        'url': 'https://example.com/login',
        'steps': [
            {
                'action': 'input',
                'selector': 'username',
                'by': 'ID',
                'value': '[email protected]',
                'description': '輸入使用者帳號'
            },
            {
                'action': 'input',
                'selector': 'password',
                'by': 'ID',
                'value': 'secure_password123',
                'description': '輸入使用者密碼'
            },
            {
                'action': 'click',
                'selector': 'login_button',
                'by': 'ID',
                'alternatives': [
                    (By.CSS_SELECTOR, 'button[type="submit"]'),
                    (By.XPATH, '//button[contains(text(), "登入")]')
                ],
                'description': '點擊登入按鈕'
            },
            {
                'action': 'wait',
                'duration': 2,
                'description': '等待頁面跳轉'
            }
        ],
        'assertions': [
            {
                'type': 'title',
                'expected': '儀表板',
                'description': '驗證成功登入後跳轉至儀表板'
            },
            {
                'type': 'element_present',
                'selector': 'user_profile',
                'by': 'ID',
                'description': '驗證使用者資料元素存在'
            }
        ]
    }
]

# 執行自動化測試
if __name__ == "__main__":
    # 初始化測試框架（使用無頭模式提高執行速度）
    tester = SmartWebTester(headless=True, timeout=15)
    
    try:
        # 執行所有測試場景
        for scenario in test_scenarios:
            tester.execute_test_scenario(scenario)
        
        # 生成測試報告
        report = tester.generate_test_report('automated_test_report.json')
        
        # 輸出測試摘要
        print("\n" + "="*50)
        print("測試執行完成")
        print(f"通過率: {report['passed']/report['total_scenarios']*100:.1f}%")
        print("="*50)
        
    finally:
        # 確保正確關閉瀏覽器
        tester.close()