Es ist wichtig, während des Software-Entwicklungsprozesses klare und effiziente单元测试 zu schreiben, die tatsächlich funktionieren.单元测试 trennen individuelle Code-Elemente und bestätigen, dass sie wie vorgesehen arbeiten.

Effektive单元测试 nicht nur Fehler erkennen, sondern helfen auch, zu确信, dass Ihr Code maintainbar und zuverlässig ist. Aber es dauert lange und erfordert Ressourcen, um manuell eine umfangreiche Suite von单元测试 zu erstellen.

Es gab in letzter Zeit einige Entwicklungen in der künstlichen Intelligenz, die versprechen, die Erstellung von单元测试 automatisieren zu helfen. Im Februar veröffentlichten Forscher bei Meta einen Artikel über Automatisierte Unitestverbesserung mittels Großsprachmodelle. Dies führte zu einer neuen Methode zur Automatisierung von单元测试.

Ihre Forschung konzentriert sich auf ein neues Werkzeug namens TestGen-LLM, das die Möglichkeiten untersucht, LLM zu verwenden, um bestehende单元测试 zu analysieren und sie zu verbessern, um die Code-Coverage zu erhöhen.

Obwohl der Code für das TestGen-LLM nicht veröffentlicht wurde, werde ich in diesem Artikel eine Open-Source-Alternative präsentieren, die von ihrer Forschung inspiriert wurde. Sie werden lernen, wie es Test-Suiten generiert, warum es besser als die meisten LLM ist und wo Sie diese Technologie erhalten und anfangen können, sie auszuprobieren.

Inhaltsverzeichnis

Meta’s TestGen-LLM

Meta’s TestGen-LLM löst die zeitraubende Aufgabe der Unit-Test-Erstellung durch die Nutzung der Macht von Großsprachmodellen (LLMs). Allgemeine LLMs wie Gemini oder ChatGPT könnten mit dem spezifischen Bereich von Unit-Test-Code, Test-Syntax und der Generierung von Tests, die keinen Wert hinzufügen, zu kämpfen haben. Aber TestGen-LLM ist speziell für Unit-Testing ausgerichtet.

Diese Spezialisierung ermöglicht es ihm, die Komplexitäten der Code-Struktur und der Testlogik zu verstehen, was zu gezielteren Test-Suites führt und Tests generiert, die tatsächlich Wert hinzufügen und die Code-Coverage erhöhen.

TestGen-LLM ist in der Lage, Unit-Tests zu bewerten und Bereiche für Verbesserungen zu identifizieren. Dies erreicht er durch seinen Verständnis von common testing patterns, mit denen er trainiert wurde. Aber die Generierung von Tests allein reicht nicht aus, um eine angemessene Code-Coverage zu erreichen.

Meta-Forscher haben innerhalb von TestGen-LLM Schutzvorkehrungen implementiert, um die Effektivität der von ihm geschriebenen Tests sicherzustellen. Diese Schutzvorkehrungen, die als Filter bezeichnet werden, agieren als Qualitätskontrollmechanismus. Sie eliminieren Vorschläge, die:

  • nicht kompilieren

  • konstistent fehlschlagen, oder

  • keine tatsächliche Verbesserung der Code-Coverage bringen (Vorschläge, die bereits von anderen Tests abgedeckt werden).

Wie funktioniert TestGen-LLM?

TestGen-LLM verwendet eine Methode namens „Assured LLM-based Software Engineering“ (Assured LLMSE). TestGen-LLM fügt einer bestehenden Testklasse lediglich zusätzliche Testfälle hinzu, behält alle bestehenden Testfälle bei und gewährleistet somit, dass es zu keiner Regression kommt.

Testgenerierungsworkflow(Aus der TestGen-LLM-Papier)

TestGen-LLM erzeugt eine Reihe von Tests, filtert anschließend die Tests aus, die nicht ausgeführt werden können, und disqualifiziert jene, die nicht bestehen. Schließlich werden diejenigen, die das Code-Coverage nicht erhöhen, verworfen.

Nachdem Meta TestGen-LLM zur Automatisierung einer Testreihe verwendet hat, wurde eine menschliche Reviewerin eingesetzt, um Tests zu akzeptieren oder abzulehnen. In ihren besten gemeldeten Fällen hatten die generierten Tests eine Akzeptanzrate von 73%.

Laut dem Papier generiert TestGen-LLM mit jedem Durchlauf einen einzigen Test, der dann zu einer bestehenden Testreihe hinzugefügt wird, die zuvor von einem Entwickler geschrieben wurde. Allerdings generiert das System nicht notwendigerweise Tests für jede Testreihe.

Die Wirksamkeit von TestGen-LLM wurde bei internen Test-a-thons bei Meta demonstriert. Hier wurde das Tool verwendet, um bestehende Testreihen zu analysieren und Verbesserungen vorzuschlagen. Die Ergebnisse waren versprechend:

“75% der Testfälle von TestGen-LLM wurden korrekt erstellt, 57% waren zuverlässig bestehen, und 25% erhöhten das Coverage. Während der Instagram- und Facebook-Test-a-thon bei Meta verbesserte es 11,5% aller Klassen, auf die es angewendet wurde, und 73% seiner Empfehlungen wurden von den Meta-Softwareingenieuren für die Produktionsdeployment akzeptiert”.

Die Empfehlungen von TestGen-LLM wurden von den Entwicklern, die an den Test-a-thons teilgenommen haben, als nützlich und relevant beurteilt.

Open-Source-Implementierung (Cover-Agent)

Die Forschung von TestGen-LLM von Meta hat das Potenzial, die Unit-Testing- und automatische Testgenerierung grundlegend zu verändern. Dieses Werkzeug wird wahrscheinlich durch die Nutzung von LLMs, die besonders auf Code ausgebildet wurden, die Code-Coverage verbessern und den Testaufbau beschleunigen helfen. Doch diese Technologie ist nicht für jeden verfügbar, da der Code für TestGen-LLM nicht veröffentlicht wurde.

Entwickler, die Interesse an dieser Technologie haben, werden wahrscheinlich durch das fehlende öffentlich zugängliche Code gefrustert sein. Nach allen Verteidigungen zeigt Meta’s TestGen-LLM-Untersuchung einen Einblick in die Zukunft, was Automatisierte Testung bedeuten kann.

Es ist reizvoll, in die internen Arbeitsweise der neuesten Technologie zu tauchen, ihre Entscheidungsprozesse zu verstehen und vielleicht sogar an ihrer Entwicklung mitzuwirken. Aber obwohl die fehlenden Meta-Codes ein Hemmnis darstellt, gibt es eine Open-Source-Implementierung namens Cover-Agent, die als hilfreiche Alternative dienen kann.

CodiumAI's Cover-Agent ist die erste Open-Source-Implementierung eines automatisierten Testwerkzeugs auf der Basis von TestGen-LLM. Inspiriert von der Meta-Forschung ist Cover-Agent nun eine der führenden Entwicklungen in Open-Source-AI-getriebener Unit-Testung dadurch.

Warum sind spezifisch auf Testen fokussierte LLM notwendig?

Da die meisten LLM (wie ChatGPT und Gemini) in der Lage sind, Tests zu generieren, dann warum sich eine neue Technologie anschaffen lassen?

Nun, Cover-Agent und TestGen-LLM wurden geschaffen, um den nächsten Schritt in der Entwicklung effizienter Unit-Tests zu markieren. Ihr Ziel ist es, common pitfalls zu vermeiden, die Entwickler in die Klemme bringen, wenn sie mit LLMs Tests generieren, wie z.B.:

  • LLM-Halluzination

  • Generierung von Tests, die keinen Wert hinzufügen

  • Generierung von Tests, die Teile des Codes auslassen, was zu niedriger Code-Coverage führt

Um solche Herausforderungen zu meistern (insbesondere für Regressionstests), haben die TestGen-LLM-Forscher die folgenden Kriterien erstellt, die die generierten Tests erfüllen müssen, bevor die Tests angenommen werden können:

  • Kompiliert das generierte Testen korrekt und führt es richtig aus?

  • Erhöht das Testen die Code-Coverage?

  • Fügt es Wert hinzu?

  • Erfüllt es eventuelle zusätzlichen Anforderungen, die wir haben?

Dies sind grundlegende Fragen und Probleme, die die generierten Tests lösen müssen, bevor sie als eine Verbesserung gegenüber der bestehenden Technologie angesehen werden können. Cover-Agent liefert Tests, die auf eine bemerkenswerte Weise auf diese Fragen und Probleme eingehen.

Wie funktioniert Cover-Agent?

Cover-Agent ist Teil einer größeren Suite von Werkzeugen, die dazu gedacht sind, den Testungsprozess für Softwareprojekte zu automatisieren. Durch die Verwendung der TestGen-LLM Generativen AI-Modelle wird versucht, diesen Prozess zu vereinfachen und zu beschleunigen, um eine hohe Qualität im Softwareentwicklungsprozess sicherzustellen.

Das System besteht aus mehreren Komponenten:

  • Test Laufer: Führt Befehle oder Skripte aus, um den Test suiten zu durchlaufen und Code-Coverage-Berichte zu generieren.

  • Coverage-Parser: Überprüft, dass der Code-Coverage zunimmt, wenn Tests hinzugefügt werden, um sicherzustellen, dass neue Tests zum Gesamt effektivität der Tests beitragen.

  • Aufforderungserstellung: Erstellt notwendige Daten aus der Codebasis und baut die Aufforderung auf, die an den Großen Sprachmodell (LLM) weitergegeben wird.

  • AI-Aufrufer: Interagiert mit dem LLM, um Tests auf der Basis der von ihm bereitgestellten Aufforderung zu generieren.

Diese Komponenten arbeiten zusammen mit TestGen-LLM, um nur Tests zu generieren, die gewährleisten, dass die bestehende Codebasis verbessert wird.

Wie man Cover-Agent nutzt

Anforderungen

Bevor Sie beginnen, Cover-Agent zu verwenden, müssen Sie Folgendes erfüllen:

  • OPENAI_API_KEY in Ihren Umgebungsvariablen gesetzt haben, was für Aufrufe der OpenAI API erforderlich ist.

  • Code-Coverage-Tool: Ein Cobertura XML Code-Coverage-Bericht ist erforderlich, damit das Tool korrekt funktioniert. Zum Beispiel könnten Sie in Python pytest-cov verwenden. Fügen Sie beim Ausführen von Pytest die Option --cov-report=xml hinzu.

Installation

Wenn Sie Cover-Agent direkt aus dem Repository verwenden, benötigen Sie auch:

  • Python auf Ihrem System installiert.

  • Poetry installiert, um Python-Paketabhängigkeiten zu verwalten. Sie können die Installationsanweisungen für Poetry hier finden.

Standalone Runtime

Sie können Cover-Agent sowohl als Python-Pip-Paket installieren als auch als eigenständiges Executable ausführen.

Python Pip

Um das Python Pip-Paket direkt über GitHub zu installieren, führen Sie folgenden Befehl aus:

pip install git+https://github.com/Codium-ai/cover-agent.git

Binärdatei

Sie können die Binärdatei ohne jegliche Python-Umgebung auf Ihrem System ausführen (z.B. innerhalb eines Docker-Containers, der kein Python enthält). Laden Sie die Veröffentlichung für Ihr System auf der Veröffentlichungsseite des Projekts herunter.

Repository Setup

Führen Sie den folgenden Befehl aus, um alle Abhängigkeiten zu installieren und das Projekt aus dem Quellcode auszuführen:

poetry install

Code Ausführen

Nach dem Herunterladen der Executable oder der Installation des Pip-Pakets können Sie Cover-Agent nun ausführen, um Unit-Tests zu generieren und zu validieren.

Führen Sie es von der Befehlszeile aus mit dem folgenden Befehl aus:

cover-agent \
--source-file-path "path_to_source_file" \
--test-file-path "path_to_test_file" \
--code-coverage-report-path "path_to_coverage_report.xml" \
--test-command "test_command_to_run" \
--test-command-dir "directory_to_run_test_command/" \
--coverage-type "type_of_coverage_report" \
--desired-coverage "desired_coverage_between_0_and_100" \
--max-iterations "max_number_of_llm_iterations" \
 --included-files "<optional_list_of_files_to_include>"

Sie können die Beispielprojekte innerhalb dieses Repositories verwenden, um diesen Code als Test auszuführen.

Kommandoargumente

  • source-file-path: Pfad der Datei, die die Funktionen oder den Code enthält, der getestet werden soll.

  • test-file-path: Pfad der Datei, in der die Tests durch den Agenten geschrieben werden. Es ist am besten, eine Skizzierung dieser Datei mit mindestens einem Test und den notwendigen Import-Anweisungen zu erstellen.

  • code-coverage-report-path: Pfad, wo der Code-Coverage-Bericht gespeichert wird.

  • test-command: Befehl, um Tests auszuführen (z.B. pytest).

  • test-command-dir: Verzeichnis, in dem der Testbefehl ausgeführt werden soll. Legen Sie dieses auf die Wurzel oder den Ort Ihrer Hauptdatei fest, um Probleme mit relativen Importen zu vermeiden.

  • coverage-type: Coverage-Typ zu verwenden. Cobertura ist ein gutes Standard-Default.

  • desired-coverage: Coverage-Ziel. Höher ist besser, obwohl 100% oft nicht praktisch ist.

  • max-iterations: Anzahl der Male, die der Agent versucht, Testcode zu generieren. Mehr Iterationen können zu höheren OpenAI-Token-Nutzung führen.

  • additional-instructions: Anweisungen, um sicherzustellen, dass der Code in einer bestimmten Weise geschrieben wird. Zum Beispiel hier könnten wir festlegen, dass der Code formatiert werden soll, um in einer Testklasse zu funktionieren.

Beim Ausführen des Befehls startet der Agent mit der Schreibung und Iteration der Tests.

Wie Cover-Agent verwendet werden kann

Es ist Zeit, Cover-Agent auszuprobieren. Wir werden eine einfache calculator.py-App verwenden, um den Code-Coverage für manuelle und automatisierte Tests zu vergleichen.

Manuelle Tests

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

Dies ist die test_calculator.py im Testordner.

# tests/test_calculator.py
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert add(2, 3) == 5

Um den Test-Coverage zu sehen, müssen wir pytest-cov installieren, eine pytest-Erweiterung für Coverage-Berichterstattung, wie zuvor erwähnt.

pip install pytest-cov

Führen Sie die Coverage-Analyse mit:

pytest --cov=calculator

Der Ausgang zeigt:

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      5    50%
-----------------------------------
TOTAL              10      5    50%

Der oben genannte Ausgang zeigt, dass 5 von den 10 Anweisungen in calculator.py nicht ausgeführt werden, was zu nur 50% Code-Coverage führt. Für eine größere Codebasis wird dies ein ernstes Problem werden und zu Rückschritten führen.

Lassen Sie uns nun sehen, ob cover-agent besser abschneidet.

Automatisierte Tests mit Cover-Agent

Um Codiums Cover-Agent einzurichten, folgen Sie diesen Schritten:

Erstens installieren Sie Cover-Agent:

pip install git+https://github.com/Codium-ai/cover-agent.git

Stellen Sie sicher, dass Ihr OPENAI_API_KEY in Ihren Umgebungsvariablen eingetragen ist, da es für die OpenAI API erforderlich ist.

Nächstes, schreiben Sie die Befehle, um in der Terminalität Tests zu generieren:

cover-agent \
--source-file-path "calculator.py" \
--test-file-path "tests/test_calculator.py" \
--code-coverage-report-path "coverage.xml" \
--test-command "pytest --cov=. --cov-report=xml --cov-report=term" \
--test-command-dir "./" \
--coverage-type "cobertura" \
--desired-coverage 80 \
--max-iterations 3 \
--openai-model "gpt-4o" \
--additional-instructions "Since I am using a test class, each line of code (including the first line) needs to be prepended with 4 whitespaces. This is extremely important to ensure that every line returned contains that 4 whitespace indent; otherwise, my code will not run."

Dadurch wird folgender Code generiert:

import pytest
from calculator import add, subtract, multiply, divide

class TestCalculator:

    def test_add(self):
        assert(add(2, 3), 5

    def test_subtract(self):
        """
        Test subtracting two numbers.
        """
        assert subtract(5, 3) == 2
        assert subtract(3, 5) == -2

    def test_multiply(self):
        """
        Test multiplying two numbers.
        """
        assert multiply(2, 3) == 6
        assert multiply(-2, 3) == -6
        assert multiply(2, -3) == -6
        assert multiply(-2, -3) == 6

    def test_divide(self):
        """
        Test dividing two numbers.
        """
        assert divide(6, 3) == 2
        assert divide(-6, 3) == -2
        assert divide(6, -3) == -2
        assert divide(-6, -3) == 2

    def test_divide_by_zero(self):
        """
        Test dividing by zero, should raise ValueError.
        """
        with pytest.raises(ValueError, match="Cannot divide by zero"):
            divide(5, 0)

Man kann sehen, dass der Agent auch Tests geschrieben hat, die auf Fehler in Ausnahmefällen prüfen.

Jetzt ist es Zeit, die Coverage noch einmal zu testen:

pytest --cov=calculator

Ausgabe:

Name            Stmts   Miss  Cover
-----------------------------------
calculator.py      10      0   100%
-----------------------------------
TOTAL              10      0   100%

In diesem Beispiel haben wir 100% Code Coverage erreicht. Für größere Codebasen ist der Prozess relativ gleich. Sie können diese Anleitung lesen, um einen Überblick über einen größeren Codebasis zu erhalten.

Obwohl Cover-Agent ein wichtiger Schritt nach vorne darstellt, ist es wichtig zu beachten, dass diese Technologie noch in ihrer frühen Phase ist. Weitere Forschung und Entwicklung sind für eine weitere Verfeinerung und eine breitere Verbreitung von Bedeutung und codiumAI lädt Sie zu Ihren Beiträgen zu dieser Open-Source-Tools ein.

Vorteile des Open Source Cover-Agent

Die Open-Source-Natur von Cover-Agent bietet mehrere Vorteile, die die Technologie voranbringen sollten. Dazu gehören:

  • Zugänglichkeit: Ihre Open-Source-Natur ermöglicht die Experimentierung mit LLM-basierten Tests und ist für Entwickler mit unterschiedlichem Hintergrund zugänglich. Dies wird die Zahl der Nutzer erhöhen und zu einer besseren Technologie sowie mehr Anwendungen führen.

  • Zusammenarbeit: Entwickler können Beiträge leisten, Verbesserungen vorschlagen, neue Features einreichen und Probleme melden. Cover-Agent wird schnell zu einem perfektionierten Projekt für Entwickler werden.

  • Transparenz: Informationen über die interne Arbeitsweise sind verfügbar und fördern Vertrauen, was letztendlich die Möglichkeiten für die Technologie erhöhen wird.

Außer den Vorteilen von Open Source bietet Cover-Agent Entwicklern eine eigene Reihe von Vorteilen:

  • Einfache Zugänglichkeit: Entwickler können leicht LLM-basierte Tests installieren und experimentieren. Dies ermöglicht eine direkte und unmittelbare Exploration der Fähigkeiten der Technologie und verursacht kaum Verzögerungen in ihrer Arbeitsweise.

  • Anpassung an spezifische Bedürfnisse: Die Open-Source-Natur von Cover-Agent ermöglicht Entwicklern, das Tool auf ihre projektbezogenen Anforderungen anzupassen. Dies könnte darin bestehen, das verwendete LLM-Modell zu ändern, Trainingsträgern Daten anzupassen, um ihre Codebasis besser abzubilden, oder Cover-Agent mit bestehenden Testframeworks zu integrieren. Dieser Grad der Anpassung gibt Entwicklern die Möglichkeit, die Kraft von LLM-basierten Tests in einer Weise zu nutzen, die mit ihren Projektbedürfnissen aligniert ist.

  • Einfache Integration: Es kann leicht mit VSCode (einem beliebten Code-Editor) integriert werden, was die Integration in bestehende Workflows erleichtert. Sie können es auch problemlos mit bestehenden menschlich verfassten Tests integrieren.

Wie können Sie zu Cover-Agent beitragen?

Der Quellcode von Cover-Agent ist öffentlich verfügbar über dieses GitHub-Repository. Sie ermutigen Entwickler aller Hintergründe, ihre Produkte zu testen und Beiträge zu leisten, um diese neue Technologie weiterzuentwickeln und zu vergrößern.

Fazit

LLM-basierte Testverbesserungswerkzeuge haben großes Potenzial, die Art und Weise zu revolutionieren, in der Entwickler unit testing ansetzen. Durch die Nutzung der Macht von großen Sprachmodellen, die speziell auf Code trainiert wurden, können diese Werkzeuge das Erstellen von Tests vereinfachen, die Codeabdeckung verbessern und letztlich die Softwarequalität verbessern.

Obwohl Meta mit TestGen-LLM wertvolle Erkenntnisse gewonnen hat, hindert die fehlende öffentlich zugängliche Quellcode auf eine breitere Verbreitung und anhaltende Entwicklung. Glücklicherweise hat Cover-Agent eine bereits zugängliche und anpassbare Lösung bereitgestellt. Es gibt Entwicklern die Möglichkeit, mit LLM-basiertem Testing zu experimentieren und zu seinen Entwicklungen beizutragen.

Das Potenzial von TestGen-LLM und Cover-Agent ist immense, und weitere Entwicklung durch Beiträge von Entwicklern wird zu einer revolutionären Werkzeug, die die automatische Testgenerierung für immer verändern, führen.

Verbinden Sie sich mit mir auf LinkedIn und Twitter, wenn Sie dies gefunden haben und es Ihnen geholfen hat.