AI Code Smell Detection: Находим Проблемы в Автотестах с Помощью ML

# Пример: Обучающие данные для детектора "Sleepy Test"

# ПЛОХО - Использует sleep
def test_user_loads_bad():
    driver.get("/users")
    time.sleep(3)  # Ждём загрузку страницы
    assert "Users" in driver.title

# ХОРОШО - Использует явное ожидание
def test_user_loads_good():
    driver.get("/users")
    WebDriverWait(driver (как обсуждается в [AI Test Metrics Analytics: Intelligent Analysis of QA Metrics](/blog/ai-test-metrics)), 10).until(
        EC.title_contains("Users")
    )
    assert "Users" in driver.title

# Обнаружение smell "Eager Test" через AST-анализ

def test_user_crud():  # SMELL: Множественные ассерты
    # Create
    user = create_user("test@example.com")
    assert user.id is not None

    # Read
    fetched = get_user(user.id)
    assert fetched.email == "test@example.com"

    # Update
    update_user(user.id, email="new@example.com")
    updated = get_user(user.id)
    assert updated.email == "new@example.com"

    # Delete
    delete_user(user.id)
    assert get_user(user.id) is None

def test_api():  # SMELL: Расплывчатое имя
    """Test the API."""  # SMELL: Бесполезный docstring
    response = requests.get("/api/users")
    assert response.status_code == 200

# Предложение AI:
def test_get_users_endpoint_returns_200_for_valid_request():
    """Проверяет, что GET /api/users возвращает 200 OK при вызове без аутентификации."""
    response = requests.get("/api/users")
    assert response.status_code == 200

from transformers import AutoTokenizer, AutoModelForSequenceClassification

# Загрузить предобученную модель, дообученную для обнаружения смеллов в тестах
model = AutoModelForSequenceClassification.from_pretrained("test-smell-detector")
tokenizer = AutoTokenizer.from_pretrained("test-smell-detector")

# Анализировать тестовый код
test_code = """
def test_login():
    driver.get("http://localhost")
    time.sleep(5)
    driver.find_element(By.ID, "username").send_keys("admin")
    driver.find_element(By.ID, "password").send_keys("secret")
    driver.find_element(By.ID, "login").click()
    time.sleep(3)
    assert "Dashboard" in driver.page_source
"""

inputs = tokenizer(test_code, return_tensors="pt", truncation=True)
outputs = model(**inputs)
predictions = outputs.logits.softmax(dim=1)

# Результаты:
# Sleepy Test: 95% уверенности
# Hard-coded значения: 78% уверенности
# Неясный ассерт: 65% уверенности

# sonar-project.properties
sonar.projectKey=test-automation
sonar.sources=tests/
sonar.python.coverage.reportPaths=coverage.xml

# Включить AI-обнаружение code smell
sonar.ai.enabled=true
sonar.ai.testSmells=true
sonar.ai.minConfidence=0.7

import ast
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_extraction.text import TfidfVectorizer

class TestSmellDetector:
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.classifier = RandomForestClassifier()

    def extract_features(self, code):
        """Извлечь фичи из тестового кода."""
        tree = ast.parse(code)

        features = {
            'lines': len(code.split('\n')),
            'assertions': code.count('assert'),
            'sleeps': code.count('time.sleep'),
            'waits': code.count('WebDriverWait'),
            'comments': code.count('#'),
            'hardcoded_strings': len(ast.literal_eval(code)),
        }
        return features

    def train(self, labeled_examples):
        """Обучить на размеченных примерах тестового кода."""
        X = [self.extract_features(code) for code, _ in labeled_examples]
        y = [label for _, label in labeled_examples]
        self.classifier.fit(X, y)

    def detect_smells(self, test_code):
        """Предсказать code smells в новом тестовом коде."""
        features = self.extract_features(test_code)
        prediction = self.classifier.predict([features])
        confidence = self.classifier.predict_proba([features])

        return {
            'has_smell': prediction[0],
            'confidence': confidence[0].max(),
            'features': features
        }

# Использование
detector = TestSmellDetector()
detector.train(training_data)

result = detector.detect_smells("""
def test_login():
    time.sleep(5)
    assert True
""")
# → {'has_smell': True, 'confidence': 0.89, 'features': {...}}

# .github/workflows/codeql.yml
name: Обнаружение Code Smell в Тестах
on: [push, pull_request]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: github/codeql-action/init@v2
        with:
          languages: python
          queries: ./.codeql/test-smells.ql
      - uses: github/codeql-action/analyze@v2

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# Загрузить модель code embedding
model = SentenceTransformer('microsoft/codebert-base')

# Embedding тестовых функций
test_codes = [
    "def test_a(): assert foo() == 1",
    "def test_b(): assert foo() == 1",  # Дубликат
    "def test_c(): assert bar() == 2",
]

embeddings = model.encode(test_codes)

# Найти похожие тесты
similarity_matrix = cosine_similarity(embeddings)

# Обнаружить дубликаты (>90% похожи)
for i in range(len(test_codes)):
    for j in range(i+1, len(test_codes)):
        if similarity_matrix[i][j] > 0.9:
            print(f"Потенциальный дубликат: тест {i} и тест {j}")
            print(f"Схожесть: {similarity_matrix[i][j]:.2%}")

# SMELL: Слишком общий ассерт
def test_api_bad():
    response = api_call()
    assert response  # Что мы на самом деле проверяем?

# ЛУЧШЕ: Конкретный ассерт
def test_api_good():
    response = api_call()
    assert response.status_code == 200
    assert "user_id" in response.json()
    assert response.json()["user_id"] > 0

# SMELL: Пустой блок catch
def test_exception_bad():
    try:
        risky_operation()
    except:
        pass  # AI флагает: Исключение проглочено

# ЛУЧШЕ: Явное тестирование исключений
def test_exception_good():
    with pytest.raises(ValueError, match="Invalid input"):
        risky_operation()

# Фичи, предсказывающие flakiness теста
flaky_features = {
    'uses_sleep': True,
    'uses_random': True,
    'accesses_network': True,
    'multi_threaded': True,
    'time_dependent': True,
    'has_race_condition_pattern': True,
}

# AI-модель предсказывает вероятность flakiness
flakiness_score = flaky_detector.predict(test_code)
# → 0.78 (78% вероятность, что этот тест flaky)

if flakiness_score > 0.6:
    print("⚠️ Обнаружен высокий риск flakiness!")
    print("Рекомендации:")
    print("- Заменить time.sleep на явные ожидания")
    print("- Замокать сетевые вызовы")
    print("- Использовать детерминированные тестовые данные")

# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: ai-test-smell-check
        name: AI-Обнаружение Code Smell в Тестах
        entry: python scripts/detect_test_smells.py
        language: python
        files: ^tests/.*\.py$
        pass_filenames: true

# .github/workflows/test-quality.yml
name: Проверка Качества Тестового Кода

on: [pull_request]

jobs:
  smell-detection:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Запустить AI-Детектор Code Smell
        run: |
          pip install test-smell-detector
          test-smell-detector --path tests/ --report report.json

      - name: Комментировать PR
        uses: actions/github-script@v6
        with:
          script: |
            const report = require('./report.json');
            const smells = report.smells.map(s =>
              `- **${s.type}** в \`${s.file}:${s.line}\`: ${s.message}`
            ).join('\n');

            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 AI-Отчёт о Code Smell в Тестах\n\n${smells}`
            });

# Отслеживание метрик смеллов со временем
import matplotlib.pyplot as plt
from datetime import datetime

class TestSmellMetrics:
    def __init__(self):
        self.history = []

    def log_scan(self, smells_detected):
        self.history.append({
            'date': datetime.now(),
            'count': len(smells_detected),
            'types': [s['type'] for s in smells_detected]
        })

    def plot_trends(self):
        dates = [h['date'] for h in self.history]
        counts = [h['count'] for h in self.history]

        plt.plot(dates, counts)
        plt.title('Code Smells в Тестах Со Временем')
        plt.xlabel('Дата')
        plt.ylabel('Количество Смеллов')
        plt.savefig('smell-trends.png')