Erhöhen der Testabdeckung in Ihrem Unternehmen mit GitHub Copilot

Grundlegendes zu Features, Aktivieren von Entwicklern und Messen der Auswirkungen von Copilot.

Wer kann dieses Feature verwenden?

GitHub Copilot Business or GitHub Copilot Enterprise

In diesem Artikel

Der Leitfaden ist inspiriert vom Engineering System Success Playbook (ESSP) von GitHub, das Strategien und Metriken für die Verbesserung von Engineeringsystemen empfiehlt.

Wenn du mit dem Rollout von Copilot beginnst, empfehlen wir, deine Ziele zu definieren, den Rollout entsprechend zu planen und die Ziele klar an Mitarbeitende zu kommunizieren. Weitere Informationen findest du unter Erreichen der Engineeringziele deines Unternehmens mit GitHub Copilot.

1. Identifizieren von Erfolgshindernissen

Der erste Schritt, der vom ESSP empfohlen wird, besteht darin, ein klares Verständnis der Hindernisse zu entwickeln, die Verbesserungen in deinem Unternehmen verhindern. Wenn du die aktuelle Baseline, den gewünschten zukünftigen Zustand und die Hindernisse für Fortschritt kennst, kannst du sicherstellen, dass Änderungen gezielt und effektiv sind.

Viele Softwareteams stellen sich dauerhaften Herausforderungen bei der Aufrechterhaltung von hochwertigem Code aufgrund geringer Komponententestabdeckung. In schnelllebigen Entwicklungsumgebungen wird das Schreiben von Tests häufig als zeitaufwendig oder nicht unbedingt notwendig angesehen, insbesondere wenn Teams unter dem Druck stehen, Features schnell bereitstellen zu müssen.

Dadurch können kritische Fehler spät im Entwicklungslebenszyklus entdeckt werden, häufig in Staging- oder Produktionsumgebungen.

Dies führt zu einer Kette negativer Ergebnisse:

  •         **Höhere Fehlerraten** und mehr vom Kunden gemeldete Probleme

  •         **Gestiegene Kosten** für die Behebung von Fehlern nach der Bereitstellung

  •         **Geringeres Vertrauen der Entwickler** in die Stabilität ihres Codes

  •         **Langsamere Veröffentlichungszyklen** aufgrund reaktiven Debuggens und Patchings

In älteren Systemen kann die Handhabung der Testabdeckung aufgrund komplexer Abhängigkeiten oder schlecht dokumentierten Codes noch schwieriger sein. Entwickler sind möglicherweise nicht mit älteren Codebasen oder mit Testframeworks vertraut, was das Problem noch weiter verstärkt.

Die Verbesserung der Testabdeckung ist eine anerkannte bewährte Methode, erfordert jedoch Zeit und Kompetenzen, die viele Teams nur schwer erbringen können.

2. Auswerten der Optionen

Der nächste Schritt besteht darin, Lösungen für die in Schritt 1 identifizierten Hindernisse zu bewerten und auszuwählen. In diesem Leitfaden konzentrieren wir uns auf die Auswirkungen, die GitHub Copilot auf das von dir identifizierte Ziel haben kann. Erfolgreiche Rollouts eines neuen Tools erfordern auch Änderungen an Kultur und Prozessen.

Führen Sie Testversionen neuer Tools und Prozesse mit Pilotgruppen aus, um Feedback zu sammeln und den Erfolg zu messen. Schulungsressourcen und Metriken, die während der Testversion verwendet werden sollen, finden Sie in den Abschnitten 3. Implementieren Sie Änderungen und Metriken, die beobachtet werden sollen.

          <a href="https://github.com/github-copilot/purchase?ref_product=copilot&ref_type=trial&ref_style=button&ref_plan=enterprise" target="_blank" class="btn btn-primary mt-3 mr-3 no-underline">
          <span>Registrieren für Copilot</span><svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-link-external" aria-label="link external icon" role="img"><path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path></svg></a>

Wie kann Copilot helfen

          GitHub Copilot kann den Prozess des Schreibens von Unit-Tests erheblich beschleunigen und vereinfachen. Wenn Sie den umgebenden Code und den Kontext verstehen, können Sie Testfunktionen vorschlagen, Copilot die der Struktur und Logik des getesteten Codes entsprechen.

          CopilotDie Funktionen sind in mehreren Szenarien nützlich:
  • Wenn Entwickler neue Funktionen schreiben, kann Copilot automatisch entsprechende Testfälle inline vorschlagen.
  • Beim Umgestalten von Legacy-Code kann Copilot dabei helfen, Testgerüste zu generieren, um Regressionen zu verhindern.
  • Bei nicht getesteten Modulen können Entwickler Copilot dazu verwenden, sinnvolle Testfälle zu generieren, selbst wenn die Testabdeckung fehlt oder inkonsistent ist.

Durch die Vereinfachung von Unit-Tests, die schneller und weniger manuell durchgeführt werden können, reduziert Copilot die Reibung, die zu Lücken bei der Testabdeckung führen kann, und hilft Teams, eine Qualitätsorientierung zu etablieren.

Anwendungsfälle

  •         **Inline-Testgenerierung**: Entwickler können Copilot bitten, Tests für eine bestimmte Funktion oder ein bestimmtes Modul zu erstellen, ohne den Kontext wechseln zu müssen.

  •         **Bessere Edgefallabdeckung**: Durch Aufforderung Copilot zu Edgeszenarien (z. B. NULL-Eingaben, leere Listen oder ungültige Zustände) können Entwickler schnell mehr Logikzweige abdecken.

  •         **Beschleunigtes Onboarding**: Neue Teammitglieder können verwenden Copilot , um zu verstehen, wie sich eine Funktion verhalten soll, indem sie sich die generierten Testfälle ansehen.

  •         **Unterstützung bei CI/CD**: Copilot kann vorschlagen, wie Tests in Ihre Buildpipeline integriert werden, um sicherzustellen, dass die Abdeckungsverbesserungen direkt die Qualitätstore unterstützen.

Kulturelle Überlegungen

Neben der Einführung von GitHub Copilot solltest du dich mit allen sozialen oder kulturellen Faktoren auseinandersetzen, die dich daran hindern könnten, deine Ziele zu erreichen.

Die folgenden Beispiele stammen aus dem Abschnitt „Anti-Patterns“ im ESSP.

  • Teams verlassen sich möglicherweise auf manuelle Tests oder unzureichende automatisierte Tests. Dies kann durch Ressourceneinschränkungen für die Automatisierung oder durch mangelnde Erfahrung mit modernen Testtools verursacht werden.
  • Teams warten möglicherweise zu lange mit der Freigabe und stellen dann große Codebatches auf einmal bereit, wodurch Fehler und Regressionen schwieriger zu erkennen sind. Dies kann durch fehlende Reife der CI/CD-Pipeline, strenge Complianceanforderungen oder lange Überprüfungszyklen zwischen PR und Bereitstellung verursacht werden.

3. Implementieren von Änderungen

Wenn Sie den richtigen Ansatz identifiziert haben, um Ihre Barrieren zu überwinden, skalieren Sie die von Ihnen identifizierten Lösungen. Wenn Sie ein neues Tool oder einen neuen Prozess erfolgreich einführen möchten, weisen Sie jedem Teil des Rollouts Den Besitz zu, kommunizieren Sie transparent über Ihre Ziele, stellen Sie effektive Schulungen bereit und messen Sie Ihre Ergebnisse.

Dieser Abschnitt enthält Beispielszenarien, bewährte Methoden und Ressourcen für Entwickelnde. Verwenden Sie diesen Abschnitt, um Kommunikations- und Schulungssitzungen zu planen , damit Mitarbeiter Copilot auf eine Weise verwenden können, die ihrem Ziel entspricht.

  •         [Tests inline generieren](#generate-tests-inline)

  •         [Grenzfälle abdecken](#cover-edge-cases)

  •         [Grundlegendes zu neuem Code](#understand-new-code)

  •         [Holen Sie sich Unterstützung bei CI/CD](#get-assistance-with-cicd)

  •         [Bewährte Methoden für Programmierende](#best-practices-for-developers)

  •         [Ressourcen für Programmierende](#resources-for-developers)

  •         [Empfohlene Features](#recommended-features)

Tests inline generieren

  1. Wählen Sie in VS Code die Funktion aus, die Sie testen möchten, und geben Sie Folgendes ein Copilot: Generate a unit test for this code.
  2.        Copilot generiert je nach Sprache und Struktur einen Test inline oder in einer separaten Testdatei.
  3. Überprüfe, verfeinere und akzeptiere den Vorschlag.

Grenzfälle abdecken

  1. Fragen Sie nach dem Schreiben eines Tests Copilot: What are some edge cases I should test for this function?

    Oder: Write test cases for when the input is null or empty.

  2.        Copilot schlägt zusätzliche Testfälle vor, um Grenzbedingungen abzudecken.

  3. Überprüfe die Tests und integriere sie in deine Testsuite.

Neues Code verstehen

  1. Wählen Sie eine Altfunktion, und fragen Sie:CopilotExplain what this function does and generate a test to validate it.
  2.        Copilot erläutert den Zweck der Funktion und schlägt entsprechende Testfälle vor.
  3. Sieh dir die Testfälle an, um das erwartete Verhalten zu verstehen und den Kontext schnell zu erstellen.

Unterstützung bei CI/CD

  1. Überprüfe deine Testfälle und führe einen Commit für die Codebasis durch.
  2. Fragen:CopilotWhere should I place this test if I want it to run in CI?
  3. Basierend auf der Struktur der Codebasis wird Copilot vorschlagen, wo Testdateien platziert werden sollen und wie Pipeline-Konfigurationen aktualisiert werden können.

Bewährte Methoden für Entwickler

          **Empfehlungen** für Programmierende:

  • Verwenden Sie beschreibende Kommentare oder Eingabeaufforderungen beim Chatten mit Copilot. Zum Beispiel: Generate unit tests for a function that calculates discounts based on user type and purchase amount.

  • Verwenden Sie Copilot, um die Logikabdeckung zu untersuchen. Zum Beispiel: What branches or conditions does this function have that should be tested?

  • Erkunde verschiedene Prompttechniken und vergleiche die Ergebnisse verschiedener KI-Modelle.

            **Entwickler sollten nicht**:

  • Akzeptiere generierte Tests ohne Überprüfen der Logik. Stelle sicher, dass die Tests die tatsächlichen Anforderungen widerspiegeln und realistische Eingaben und Ausgaben verarbeiten.

  • Überspringen der Überprüfung des Kantenverhaltens. Wenn du nur „fröhliche Pfade“ testest, riskierst du, dass dir Regressionen entgehen.

  • Verlassen Sie sich auf Copilot , um nicht dokumentierte Geschäftsregeln zu erraten. Stelle immer Kontext über Prompts oder Kommentare bereit.

  • Behandeln Sie Copilot als Ersatz für menschliche Codeüberprüfungen. Copilot beschleunigt den Prozess, aber Sie müssen dennoch technische Beurteilungen anwenden.

Ressourcen für Entwickler

  •         [AUTOTITLE](/copilot/using-github-copilot/guides-on-using-github-copilot/writing-tests-with-github-copilot)

  •         [Generieren von Komponententests mit GitHub Copilot: Tipps und Beispiele](https://github.blog/ai-and-ml/github-copilot/how-to-generate-unit-tests-with-github-copilot-tips-and-examples/)

  •         [
        GitHub Copilot ist ÜBERALL in Visual Studio](https://learn.microsoft.com/en-us/shows/github-copilot-for-visual-studio/github-copilot-is-everywhere-in-visual-studio-miniseries) (Videoinhalte mit einem Abschnitt zum Testen)

  •         [AUTOTITLE](/copilot/using-github-copilot/copilot-chat/prompt-engineering-for-copilot-chat)

  •         [AUTOTITLE](/copilot/using-github-copilot/ai-models/changing-the-ai-model-for-copilot-chat)
  • Copilot-Chat in GitHub
  •         [
        Copilot Inlinevorschläge](/copilot/using-github-copilot/getting-code-suggestions-in-your-ide-with-github-copilot)

  •         [
        Copilot-Chat in der IDE](/copilot/using-github-copilot/copilot-chat/asking-github-copilot-questions-in-your-ide)
  • Copilot Cloudagent

Zu überwachende Metriken

Um Testversionen neuer Tools zu bewerten und sicherzustellen, dass Ihre vollständigen Rollouts konsistente Verbesserungen bieten, überwachen Sie die Ergebnisse, und nehmen Sie bei Bedarf Anpassungen vor. Wir empfehlen, die wichtigsten Bereiche der Qualität, Geschwindigkeit und Entwicklerzufriedenheit zu berücksichtigen und wie diese Zonen zusammenkommen, um zu geschäftsergebnissen beizutragen.

Hier sind einige Metriken zur Bewertung der Auswirkungen von Copilot auf dieses spezielle Ziel.

  •         **Testabdeckung**: Nachverfolgen von Anstiegen der Linien- und Zweigabdeckung nach Copilot der Einführung. Sieh dir nach Möglichkeit Testabdeckungsberichte aus deinen CI-Pipelines an.

  •         **Fehlerrate nach der Bereitstellung**: Weniger Fehler sollten in Produktionsumgebungen gemeldet werden.

  •         **Entwicklervertrauen**: Verwende Umfragen oder Retrospektiven, um zu beurteilen, wie sicher sich Entwickler fühlen, wenn sie neuen Code liefern.

  •         **Zeit zum Schreiben von Tests**: Miss die Reduzierung der Zeit, die für das Erstellen von Unittests aufgewendet wird.