Sollten wir Code für die Code-Coverage-Analyse ausschließen?

Ich arbeite an mehreren Anwendungen, hauptsächlich älteren. Gegenwärtig ist ihre Codeabdeckung recht gering: im Allgemeinen zwischen 10 und 50%.

Seit einigen Wochen führen wir immer wieder Gespräche mit den Bangalore-Teams (der größte Teil der Entwicklung findet in Indien im Ausland statt) über den Ausschluss von Paketen oder Klassen für Cobertura (unser Code-Coverage-Tool, auch wenn wir derzeit auf JaCoCo migrieren).

Ihre Sichtweise ist folgende: Da sie auf einigen Ebenen der Anwendung (1) keine Komponententests schreiben , sollten diese Ebenen einfach von der Kennzahl für die Codeabdeckung ausgeschlossen werden. Mit anderen Worten, sie möchten das Maß für die Codeabdeckung auf den Code beschränken, der getestet wird oder getestet werden soll .

Wenn sie am Komponententest für eine komplexe Klasse arbeiten, werden die Vorteile - rein in Bezug auf die Codeabdeckung - in einer großen Anwendung unbemerkt bleiben. Durch die Reduzierung des Umfangs der Codeabdeckung wird diese Art von Aufwand sichtbarer ...

Das Interesse dieses Ansatzes ist, dass wir eine Kennzahl für die Codeabdeckung haben, die den aktuellen Status des Teils der Anwendung angibt, den wir als testbar betrachten .

Mein Standpunkt ist jedoch, dass wir die Zahlen irgendwie vortäuschen. Diese Lösung ist eine einfache Möglichkeit, ohne großen Aufwand eine höhere Codeabdeckung zu erreichen. Ein weiterer Punkt, der mich stört, ist der folgende: Wenn wir von einer Woche zur nächsten eine Zunahme der Abdeckung feststellen, wie können wir dann feststellen, ob diese gute Nachricht auf die gute Arbeit der Entwickler oder einfach auf neue Ausschlüsse zurückzuführen ist?

Außerdem können wir nicht genau wissen, was in der Codeabdeckungsmaßnahme berücksichtigt wird. Wenn ich zum Beispiel eine 10.000-Zeilen-Code-Anwendung mit 40% Codeabdeckung habe, kann ich abziehen, dass 40% meiner Codebasis getestet wurden (2) . Aber was passiert, wenn wir Ausschlüsse festlegen? Wenn die Codeabdeckung jetzt 60% beträgt, was kann ich dann genau abziehen? Dass 60% meiner "wichtigen" Codebasis getestet werden? Wie kann ich

Was mich betrifft, ziehe ich es vor, den "echten" Codeabdeckungswert beizubehalten, auch wenn wir nicht fröhlich darüber sein können. Dank Sonar können wir außerdem problemlos in unserer Codebasis navigieren und für jedes Modul, jedes Paket und jede Klasse eine eigene Codeabdeckung ermitteln. Aber die globale Code-Abdeckung wird natürlich immer noch gering sein.

Was ist Ihre Meinung zu diesem Thema? Wie machst du deine Projekte?

Vielen Dank.

(1) Diese Ebenen beziehen sich im Allgemeinen auf die UI / Java-Beans usw.

(2) Ich weiß, dass das nicht stimmt. In der Tat bedeutet es nur, dass 40% meiner Codebasis

Im Allgemeinen schließe ich automatisch generierten Code aus, z. B. die von Visual Studio generierten WCF-Clients. Es gibt normalerweise viele Codezeilen und wir werden sie nie testen. Dies macht es sehr demoralisierend, die Tests für einen großen Teil des Codes an anderer Stelle zu erhöhen und die Codeabdeckung nur um 0,1% zu erhöhen.

Ich werde auch Daten-Layer-Interaktionen ausschließen, solange das Team mit Sicherheit sagen kann, dass dieser Layer so dünn wie möglich ist. Sie können zwar argumentieren, dass eine dünne Schicht keinen massiven Effekt hat, jedoch viele Komponenten im Abdeckungsbericht mit 0% dagegen belassen, sodass wir die benötigten Komponenten nicht unbedingt bemerken sich wirklich Sorgen machen. Die UI-Ebene könnte je nach verwendetem Framework auf ähnliche Weise argumentiert werden.

Im Gegenzug werde ich aber auch die Unit-Tests selbst ausschließen. Sie sollten immer eine Abdeckung von ~ 100% haben und einen großen Prozentsatz der Codebasis ausmachen, wodurch die Zahlen gefährlich nach oben verzerrt werden.

Gute Frage. Im Allgemeinen neige ich dazu, Code aus bestimmten Gründen von der Codeabdeckung auszuschließen, z. B .:

• erzeugt
• Vermächtnis (nicht mehr aktualisiert)
• hier kommt es: bestimmte schichten habe ich nicht vor zu testen

Warum der letzte Punkt? Ich denke, es ist eine gute Praxis, sich auf Dinge zu konzentrieren, die mir wichtig sind, und Ablenkungen zu unterdrücken. Wenn Sie nicht vorhaben, den UI-Layer zu testen, sollten Sie ihn in Betracht ziehen - er lenkt die Aufmerksamkeit nur von dem wichtigen Teil Ihrer Software ab - der Geschäftslogik.

ABER:

1. Sie sollten einen guten Grund haben, warum Sie eine bestimmte Ebene von Unit-Tests ausschließen sollten (es kann Fragen geben - von Ihrem Chef, Ihren Teamkollegen, der Presse ;-)
2. Wenn Sie möchten, dass sie diese Ebenen testen, sollten Sie sie in die Statistiken aufnehmen, um dem gesamten Team jeden Tag zu zeigen, dass es wichtig ist und getan werden muss.

Zum Schluss: Nimm die Zahlen nicht zu ernst. 30% Deckung können einen Software-Grundbestandteil beweisen, wenn er der wesentliche Bestandteil davon ist.

Ich stimme Ihnen in der Regel zu und beziehe den gesamten relevanten Code in die Metriken für die Codeabdeckung ein (und Sonar im Allgemeinen). Auch wenn Sie nicht vorhaben, einige Teile des Codes (auf absehbare Zeit) zu testen, sollten die Metriken den tatsächlichen Status widerspiegeln. Dies zwingt Sie zu einem zwingenden Grund, keine Tests für einen wesentlichen Teil der Codebasis zu schreiben. Eventuell (sobald andere, wichtigere Teile des Codes bereits behandelt wurden) können Sie diese Dissonanz überdenken oder einen anderen Weg wählen, um sie zu beseitigen - z einen anderen, prüfbaren Teil der Codebasis oder sogar die gesamte Ebene zu entfernen (wenn eine Ebene nicht prüfenswert ist, hat sie einen hinreichenden Grund zu existieren?)

In meinen aktuellen Projekten wird auch der gesamte Code in Metriken eingeschlossen, mit einer Ausnahme: generierter Code, der zahlreiche Warnungen zur statischen Analyse generiert. Da dieser Code normalerweise aus riesigen POD-Klassen ohne Logik besteht, gibt es dort sowieso nichts zu testen.

Jetzt bin ich weder mit den von Ihnen verwendeten Code-Coverage-Tools vertraut, noch bin ich mit den Java-Beans vertraut, aber was Sie sagen, hat etwas mit der Benutzeroberfläche zu tun.

Mit meinen begrenzten Kenntnissen habe ich folgendes zu sagen:

1. Lassen Sie sich bei Ihren Tests nicht durch Zahlen von Testwerkzeugen behindern.
2. Wenn die Klassen komplex und nicht Unit-testbar sind, ist es immer eine gute Idee, sie in kompaktere und testbarere Klassen umzuwandeln. Es wird viel Mühe und Engagement erfordern, aber es wird sich auf lange Sicht auszahlen.
3. Das Testen von UI-Komponenten kann schwierig sein, aber Sie können trotzdem die Funktion testen, die von diesen Komponenten ausgeführt wird.
4. Wenn Sie ein webbasiertes Projekt ausführen, können Sie QUnit verwenden, um den gesamten clientseitigen Code zu testen.

Alles in allem sollten Sie bedenken, dass die Codeabdeckung nur eine Zahl ist und eine hohe Codeabdeckung keine guten Tests anzeigt. Konzentrieren Sie sich darauf, die Kernbibliotheken robuster und testbarer zu machen, anstatt einen höheren Prozentsatz anzustreben.

Einige Ausschlüsse sind sinnvoll (Kesselschildcode, der keine wirklichen Auswirkungen oder Auswirkungen auf die ordnungsgemäße Funktion Ihres Projekts hat). Sogar das Sammeln von Code-Coverage als Metrik ist sinnlos, da es Ihnen sowieso nichts Sinnvolles sagt. Eine Codeabdeckung von 100% ist kein echtes Ziel, und niedrige Abdeckungszahlen können je nach Projekt auch nicht schlecht sein. Möglicherweise deckt eine Codeabdeckung von 20 bis 30% alles ab, was einen Test wert ist. Die Codeabdeckung gibt nur an, dass X% Ihres Codes, der möglicherweise abgedeckt werden sollte, durch eine Art Test von unbekannter Qualität erfolgt.

Ich schlage vor, eine Reihe von Metriken für jede Ebene Ihres Codes zu melden. Diese Metriken sollten Größeninformationen (z. B. LoC, Anzahl der Bibliotheken, Anzahl der Klassen oder Methoden usw.), Testinformationen (z. B. Abdeckung) und Fehlerinformationen (z. B. Auffinden und Beheben von Raten) enthalten.

Ihre ausgeschlossenen Schichten haben eine Deckung von 0%, und Ihre getesteten Gebiete haben die von Ihnen erwähnte Deckung von 60%. Anhand der Größeninformationen können die Benutzer nachvollziehen, wie viel ungetestet oder getestet ist. Anhand der Fehlerinformationen erfahren Sie, ob Sie möglicherweise Tests für die ausgeschlossenen Ebenen erstellen und ob Ihre vorhandenen Tests funktionieren.

Für Softwareunternehmen ist es leicht, sich zu sehr auf die Reinheit von Metriken zu konzentrieren. Wir machen keine Metriken, wir machen gute Software. Eine Metrik, mit der Sie qualitativ hochwertige Software rechtzeitig bereitstellen können, ist die ehrlichste und reinste Metrik, die es gibt.