Setzen Sie Unit-Tests in dasselbe oder ein anderes Projekt ein?

137

Platzieren Sie Unit-Tests der Einfachheit halber im selben Projekt oder in einer separaten Baugruppe?

Wenn Sie sie wie wir in eine separate Baugruppe stellen, erhalten Sie eine Reihe zusätzlicher Projekte in der Lösung. Es eignet sich hervorragend für Unit-Tests beim Codieren. Wie können Sie die Anwendung jedoch ohne all diese zusätzlichen Assemblys freigeben?

Leora
quelle

Antworten:

100

Meiner Meinung nach sollten Unit-Tests in einer vom Produktionscode getrennten Baugruppe platziert werden. Hier sind nur einige Nachteile der Platzierung von Komponententests in derselben Baugruppe oder denselben Baugruppen wie der Produktionscode:

  1. Unit-Tests werden mit Produktionscode geliefert. Das einzige, was mit dem Produktcode geliefert wird, ist der Produktionscode.
  2. Baugruppen werden durch Unit-Tests unnötig aufgebläht.
  3. Unit-Tests können Build-Prozesse wie automatisierte oder kontinuierliche Builds beeinflussen.

Ich kenne keine Profis. Ein zusätzliches Projekt (oder 10) zu haben, ist kein Nachteil.

Bearbeiten: Weitere Informationen zu Build und Versand

Ich würde außerdem empfehlen, dass bei jedem automatisierten Bauprozess Produktions- und Komponententests an verschiedenen Orten durchgeführt werden. Im Idealfall wird der Unit-Test-Erstellungsprozess nur ausgeführt, wenn der Produktionscode erstellt wird, und die Produktdateien werden in das Unit-Test-Verzeichnis kopiert. Wenn Sie dies auf diese Weise tun, werden die tatsächlichen Bits für den Versand usw. getrennt. Außerdem ist es ziemlich trivial, an dieser Stelle für alle Tests in einem bestimmten Verzeichnis automatisierte Komponententests durchzuführen.

Zusammenfassend ist hier die allgemeine Idee für ein tägliches Erstellen und Testen und Versenden von Bits und anderen Dateien:

  1. Der Produktions-Build wird ausgeführt und die Produktionsdateien werden in einem bestimmten "Produktions" -Verzeichnis abgelegt.
    1. Erstellen Sie nur Produktionsprojekte.
    2. Kopieren Sie kompilierte Bits und andere Dateien in ein "Produktions" -Verzeichnis.
    3. Das Kopieren von Bits und anderen Dateien in ein Release Candidate-Verzeichnis, auch bekannt als Christmas Release Directory, wäre "Release20081225".
  2. Wenn der Produktionsbuild erfolgreich ist, wird der Unit-Test-Build ausgeführt.
    1. Kopieren Sie den Produktionscode in das Verzeichnis "tests".
    2. Erstellen Sie Komponententests im Verzeichnis "tests".
    3. Führen Sie Unit-Tests durch.
  3. Senden Sie Build-Benachrichtigungen und Unit-Testergebnisse an Entwickler.
  4. Wenn ein Release-Kandidat (wie Release20081225) akzeptiert wird, versenden Sie diese Bits.
Jason Jackson
quelle
15
IMO sind die Nachteile, die Sie auflisten, nicht immer anwendbar. Ein Profi für dasselbe Projekt ist die einfachere Gruppierung getesteter Klasse + Tests - diese kleinen Annehmlichkeiten sind beim Schreiben von Tests von großer Bedeutung. Persönliche Vorlieben gewinnen hier, und manchmal sind Ihre Punkte relevant, nur nicht immer.
Orip
7
Sie sollten zuerst fragen, ob Sie die Tests beim Versand entfernen müssen. Wenn ja, benötigen Sie ein separates Projekt. Wenn nicht, entscheiden Sie anhand der anderen Vor- und Nachteile. Personen, die davon ausgehen, dass sie die Tests nicht bereitstellen können, gelangen standardmäßig immer zu der Schlussfolgerung "Separates Projekt".
Orip
7
Ich sehe keine Vorteile beim Versand von Nicht-Produktionscode wie Unit-Tests, und es gibt viele Nachteile. Versandeinheitentests bedeuten, dass Sie mit mehr Bits zu tun haben, die verteilt werden müssen. Unit-Tests haben auch einen separaten Satz von Abhängigkeiten. Jetzt versenden Sie NUnit, Rhino oder Moq usw. Das ist noch mehr aufgebläht. Das Platzieren von Komponententests in einem separaten Projekt erfordert nur einen geringen Aufwand, und das sind einmalige Kosten. Ich bin sehr zufrieden mit der Schlussfolgerung, dass Unit-Tests nicht versendet werden sollten.
Jason Jackson
4
Als Alternative zum "separaten Projekt" -Ansatz zum Entfernen von Komponententests im Produktionscode sollten Sie ein benutzerdefiniertes Symbol und Compiler-Anweisungen wie verwenden #if. Dieses benutzerdefinierte Symbol kann mithilfe von Compiler-Befehlszeilenparametern in Ihren CI-Software-Skripten umgeschaltet werden. Siehe msdn.microsoft.com/en-us/library/4y6tbswk.aspx .
Rich C
23
.NET steht hinter der Kurve, wenn es darum geht, Tests in einem völlig separaten Projekt durchzuführen, und ich würde wetten, dass sich dies bald ändern wird. Es gibt keinen Grund, warum der Erstellungsprozess nicht dazu gebracht werden konnte, Testcode im Release-Build zu ignorieren. Ich habe mehrere Web-App-Generatoren verwendet, die dies tun. Ich denke, es ist absolut besser, Unit-Test-Codedateien direkt neben den von ihnen beschriebenen Codedateien einzuschließen, die in derselben Dateihierarchie verteilt sind. Google empfiehlt dies als "fraktale" Dateiorganisation. Warum unterscheiden sich Tests von Inline-Kommentaren und Readme-Dokumentation? Letzteres ignoriert der Compiler gerne.
Brandon Arnold
112

Separates Projekt, aber in der gleichen Lösung. (Ich habe an Produkten mit separaten Lösungen für Test- und Produktionscode gearbeitet - es ist schrecklich. Sie wechseln immer zwischen den beiden.)

Die Gründe für getrennte Projekte sind wie von anderen angegeben. Beachten Sie, dass bei Verwendung datengesteuerter Tests möglicherweise eine erhebliche Aufblähung auftritt, wenn Sie die Tests in die Produktionsbaugruppe aufnehmen.

Wenn Sie Zugriff auf die internen Elemente des Produktionscodes benötigen, verwenden Sie InternalsVisibleTo .

Jon Skeet
quelle
+1: Ich bin gerade auf Komponententests im selben Projekt wie der Hauptcode gestoßen, und es ist schwierig, die Tests im realen Code zu finden - obwohl eine Namenskonvention befolgt wurde.
Fenton
31
Für weniger erfahrene Leser bedeutet dies, dass Sie [assembly:InternalsVisibleTo("UnitTestProjectName")]Ihrer Projektdatei hinzufügen AssemblyInfo.cs.
Margus
Sehr nützliche Ergänzung Margus. Vielen Dank an Jon für die Erwähnung von InternalsVisibleTo in diesem Zusammenhang.
Bjørn Otto Vasbotten
1
@jropella: Wenn Sie die Produktbaugruppe signieren, können Sie die Interna ohnehin nur für signierte Baugruppen sichtbar machen. Und natürlich, wenn Sie einen Code in vollem Vertrauen ausführen, haben sie Zugriff über Reflexion ...
Jon Skeet
2
@jropella: Reflection kümmert sich sowieso nicht um InternalsVisibleTo ... aber Sie hätten keine signierte Assembly gesehen, die einer nicht signierten Assembly mit InternalsVisibleTo vertraut , da dies beim Kompilieren verhindert wird.
Jon Skeet
70

Ich verstehe den häufigen Einwand gegen die Bereitstellung von Tests mit Produktionscode nicht. Ich leitete ein Team mit einer kleinen Mikrokappe (wuchs von 14 auf 130 Personen). Wir hatten ungefähr ein halbes Dutzend Java-Apps und fanden es EXTREM wertvoll, Tests vor Ort bereitzustellen, um sie auf einem auszuführen bestimmtenMaschine, die ungewöhnliches Verhalten zeigte. Zufällige Probleme treten vor Ort auf, und es war von unschätzbarem Wert, einige tausend Komponententests ohne Kosten auf das Rätsel zu werfen, und es wurden häufig Probleme innerhalb von Minuten diagnostiziert ... einschließlich Installationsproblemen, flockigen RAM-Problemen, maschinenspezifischen Problemen, flockigen Netzwerkproblemen, usw. usw. Ich denke, es ist unglaublich wertvoll, Tests vor Ort durchzuführen. Außerdem tauchen zu zufälligen Zeiten zufällige Probleme auf, und es ist schön, dass die Unit-Tests dort bereits darauf warten, sofort ausgeführt zu werden. Festplattenspeicher ist billig. Genau wie wir versuchen, Daten und Funktionen zusammenzuhalten (OO-Design), denke ich, dass es von grundlegender Bedeutung ist, Code und Tests zusammenzuhalten (Funktion + Tests, die die Funktionen validieren).

Ich möchte meine Tests in dasselbe Projekt in C # /. NET / Visual Studio 2008 einfügen, aber ich habe dies noch nicht genug untersucht, um es zu erreichen.

Ein großer Vorteil von Foo.cs im selben Projekt wie FooTest.cs ist, dass Entwickler ständig daran erinnert werden, wenn einer Klasse ein Geschwistertest fehlt! Dies fördert bessere testgetriebene Codierungspraktiken ... Löcher sind offensichtlicher.


quelle
17
Ich kann sehen, wie wertvoll das bei Integrationstests wäre, aber bei Unit-Tests? Wenn Sie sie richtig schreiben, sollten sie keine Abhängigkeiten vom Computer haben.
Joel McBeth
+1 Ich stimme zu. Da ich hauptsächlich .NET mache, hat das Versenden von Tests mit Produktionscode auch den netten Nebeneffekt, dass der kontinuierliche Integrationsschritt von Kompilieren und Testen reduziert wird: 1) Nur die Hälfte der zu erstellenden Projekte, 2) alle Testbaugruppen anstelle der Hauptanwendung So ist es einfacher, Ihren Testläufer zu parametrisieren. Bei Verwendung von Maven gilt dieses Argument natürlich nicht. Schließlich sind meine Kunden eher technische Leute und möchten die Tests wirklich gerne selbst durchführen, da dies den aktuellen Status anhand der Spezifikation dokumentiert.
mkoertgen
Ich denke, es kann durchaus sinnvoll sein, Integrationstests im TDD / BDD-Stil durchzuführen, dh Testcode zu schreiben, der mit Standardtestläufern wie NUnit, xUnit usw. leicht automatisiert werden kann. Natürlich sollten Sie die Einheit nicht mit Integrationstests verwechseln. Stellen Sie einfach sicher, dass Sie wissen, welche Tests schnell und häufig für die Build-Überprüfung (BVT) und welche für Integrationstests ausgeführt werden müssen.
mkoertgen
1
Der Grund, warum die Leute dagegen sind, ist, dass sie das nicht gewohnt sind. Wenn ihre ersten Erfahrungen mit Unit-Tests darin bestanden, dass sie sich innerhalb des Produktionscodes befanden und tatsächlich eine spezifische Syntax in der Programmiersprache hatten, die angab, was ein Test mit einer Produktionsmethode verbunden ist, würden sie schwören, dass dies ein unschätzbarer Aspekt des Entwicklungsworkflows ist und es ist absolut verrückt, sie in ein separates Projekt zu setzen. Die meisten Entwickler sind so. Anhänger.
zumalifeguard
19

Fügen Sie Unit-Tests in dasselbe Projekt wie den Code ein, um eine bessere Kapselung zu erzielen.

Sie können interne Methoden problemlos testen. Dies bedeutet, dass Sie keine Methoden veröffentlichen, die intern sein sollten.

Es ist auch sehr schön, wenn die Unit-Tests in der Nähe des Codes liegen, den Sie schreiben. Wenn Sie eine Methode schreiben, können Sie die entsprechenden Komponententests leicht finden, da sie sich im selben Projekt befinden. Wenn Sie eine Assembly erstellen, die unitTests enthält, erhalten Sie bei Fehlern im unitTest einen Kompilierungsfehler. Sie müssen also Ihre Unittest auf dem neuesten Stand halten, nur um sie zu erstellen. Wenn Sie in einem separaten Projekt unittest haben, können einige Entwickler vergessen, das unittest-Projekt zu erstellen, und die fehlerhaften Tests für eine Weile verpassen.

Sie können die Komponententests mithilfe von Kompilierungs-Tags (IF #Debug) aus dem Produktionscode entfernen.

Automatische Integrationstests (erstellt in NUnit) sollten sich in einem separaten Projekt befinden, da sie keinem einzelnen Projekt angehören.

jenspo
quelle
1
Dies bedeutet jedoch, dass Sie keine Tests für den ReleaseBuild ausführen können und nur wenige "Heisenbugs" durchfallen können.
HPPy
3
Mit Freund-Assemblys ( msdn.microsoft.com/en-us/library/0tke9fxk.aspx ) InternalsVisibleTokönnen Sie interne Methoden aus einem separaten Testprojekt testen
ParoX
3
@hlpPy - Sie können beliebige bedingte Kompilierungssymbole konfigurieren und mehr als 2 Build-Konfigurationen haben. Z.B; Sie könnten haben Debug, Approvalund Release; und kompilieren Sie die Genehmigung mit allen Release-Optimierungen. Außerdem sind Unit-Tests in der Regel nicht in der Lage, Heisenbugs überhaupt zu erkennen (meiner Erfahrung nach). Sie benötigen in der Regel spezielle Integrationsregressionstests für diese - und Sie können diese möglicherweise nebeneinander platzieren.
Eamon Nerbonne
Ein separates Projekt gibt den gleichen Fehler bei der Kompilierung aus. Wenn Sie so tief in den Code eintauchen müssen, brauchen Sie mehr Abstraktionen als Hack-Unit-Tests in Ihren Code. Es ist auch nicht gut, sich auf Bedingungen in Ihrem Code zu verlassen, um Zweige zu wechseln. Klingt eher so, als würden Unit- und Integrationstests verwirrt.
Nick Turner
12

Nachdem ich einige Zeit in TypeScript-Projekten verbracht hatte, in denen Tests häufig neben dem zu testenden Code in einer Datei abgelegt werden, zog ich diesen Ansatz vor, anstatt sie getrennt zu halten:

  • Es ist schneller, zur Testdatei zu navigieren.
  • Es ist einfacher, sich daran zu erinnern, die Tests umzubenennen, wenn Sie die zu testende Klasse umbenennen.
  • Es ist einfacher, sich daran zu erinnern, die Tests zu verschieben, wenn Sie die zu testende Klasse verschieben.
  • Es ist sofort klar, ob einer Klasse Tests fehlen.
  • Sie müssen nicht zwei doppelte Dateistrukturen verwalten, eine für Tests und eine für Code.

Als ich kürzlich ein neues .NET Core-Projekt startete, wollte ich sehen, ob es möglich ist, diese Struktur in einem C # -Projekt nachzuahmen, ohne die Tests oder Testassemblys mit der endgültigen Version zu versenden.

Das Einfügen der folgenden Zeilen in die Projektdatei scheint bisher gut zu funktionieren:

  <ItemGroup Condition="'$(Configuration)' == 'Release'">
    <Compile Remove="**\*.Tests.cs" />
  </ItemGroup>
  <ItemGroup Condition="'$(Configuration)' != 'Release'">
    <PackageReference Include="nunit" Version="3.11.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="3.12.0" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
  </ItemGroup>

Das obige stellt sicher, dass in der ReleaseKonfiguration alle Dateien benannt sind*.Tests.cs von der Kompilierung ausgeschlossen werden und dass die erforderlichen Verweise auf Unit-Test-Pakete entfernt werden.

Wenn Sie weiterhin in der Lage sein möchten, die Klassen in ihrer Release-Konfiguration zu testen, können Sie einfach eine neue Konfiguration erstellen, die von Releaseso etwas wie abgeleitet abgeleitet ist ReleaseContainingTests.


Update: Nachdem ich diese Technik eine Weile verwendet habe, habe ich auch festgestellt, dass es hilfreich ist, Ihre Symbole in VS Code anzupassen, damit die Tests (und andere Dinge) im Explorer-Bereich etwas besser zur Geltung kommen:

VS Code Screenshot

Verwenden Sie dazu die Erweiterung Material Icon Theme und fügen Sie Ihren VS Code-Einstellungen JSON Folgendes hinzu:

"material-icon-theme.files.associations": {
  "*.Tests.cs": "test-jsx",
  "*.Mocks.cs": "merlin",
  "*.Interface.cs": "yaml",
}
James Thurley
quelle
Genau das, was wir gerade angefangen haben
Matthew Steeples
10

Meine Unit-Tests finden immer in einem separaten Projekt statt. Tatsächlich gibt es für jedes Projekt, das ich in meiner Lösung habe, ein separates Testprojekt, das damit einhergeht. Testcode ist kein Anwendungscode und sollte nicht damit vermischt werden. Ein Vorteil, wenn Sie sie in separaten Projekten aufbewahren - zumindest mit TestDriven.Net -, besteht darin, dass ich mit der rechten Maustaste auf ein Testprojekt klicken und alle Tests in diesem Projekt ausführen kann, wobei ich mit einem Klick eine gesamte Bibliothek mit Anwendungscode teste.

Tvanfosson
quelle
1
Wie testest du dann interne Klassen? Oder testen Sie nur die öffentlichen Klassen?
user19371
7
<Assembly: InternalsVisibleTo = "TestProject" /> falls erforderlich, obwohl ich normalerweise nur öffentliche Schnittstellen teste.
Tvanfosson
@tvanfosson, was machst du mit Specs (Specflow)? Hätten Sie ein separates Projekt oder würden Sie diese in das Unit Test-Projekt aufnehmen? +1.
w0051977
@ w0051977 Ich habe Specflow noch nie benutzt, daher weiß ich es nicht
tvanfosson
@tvanfosson, was ist mit Integrationstests? Würden Sie sie in einem separaten Projekt zu den Unit-Tests einfügen?
w0051977
10

Wenn das NUnit- Framework verwendet wird, gibt es einen zusätzlichen Grund, die Tests in dasselbe Projekt zu integrieren. Betrachten Sie das folgende Beispiel des Produktionscodes, der mit Komponententests gemischt ist:

public static class Ext
{
     [TestCase(1.1, Result = 1)]
     [TestCase(0.9, Result = 1)]
     public static int ToRoundedInt(this double d)
     {
         return (int) Math.Round(d);
     }
}

Die Unit-Tests dienen hier als Dokumentation und Spezifikation für den zu testenden Code. Ich weiß nicht, wie ich diesen Effekt der Selbstdokumentation erreichen kann, wenn sich die Tests in einem separaten Projekt befinden. Der Benutzer der Funktion müsste nach den Tests suchen, um diese Testfälle zu sehen, was unwahrscheinlich ist.

Update : Ich weiß, dass eine solche Verwendung von TestCaseAttributen nicht von den Entwicklern von NUnit beabsichtigt wurde, aber warum nicht?

Andrej Adamenko
quelle
2
Ich mag diese Idee; mit ein paar Beispielen für Eingaben und erwartete Ausgaben genau dort mit dem Code.
Preston McCormick
3

Ich schwanke zwischen demselben Projekt und verschiedenen Projekten.

Wenn Sie eine Bibliothek freigeben, ist es ein Problem, den Testcode mit dem Produktionscode freizugeben. Andernfalls ist dies normalerweise nicht der Fall (obwohl es vor dem Versuch eine starke psychologische Barriere gibt).

Wenn ich Tests in dasselbe Projekt einbaue, fällt es mir leichter, zwischen Tests und dem von ihnen getesteten Code zu wechseln und sie leichter umzugestalten / zu verschieben.

orip
quelle
3

Ich habe sie in separate Projekte gestellt. Der Name der Assembly entspricht in der Regel dem der Namespaces. Wenn es also ein Projekt mit dem Namen Company.Product.Feature.sln gibt, hat es eine Ausgabe (Baugruppenname) von Company.Product.Feature.dll. Das Testprojekt ist Company.Product.Feature.Tests.sln und ergibt Company.Product.Feature.Tests.dll.

Sie sollten sie am besten in einer einzigen Lösung aufbewahren und die Ausgabe über den Konfigurationsmanager steuern. Wir haben eine benannte Konfiguration für jeden der Hauptzweige (Entwicklung, Integration, Produktion) anstelle der Verwendung des Standard-Debugs und der Standardversion. Sobald Sie Ihre Konfigurationen eingerichtet haben, können Sie sie ein- oder ausschließen, indem Sie im Konfigurationsmanager auf das Kontrollkästchen "Erstellen" klicken. (Um den Configuration Manager zu erhalten, klicken Sie mit der rechten Maustaste auf die Lösung und gehen Sie zu Configuration Manager.) Beachten Sie, dass das CM in Visual Studio manchmal fehlerhaft ist. Einige Male musste ich in die Projekt- und / oder Lösungsdateien gehen, um die von ihr erstellten Ziele zu bereinigen.

Wenn Sie Team Build verwenden (und ich bin sicher, dass andere .NET-Build-Tools identisch sind), können Sie den Build außerdem einer benannten Konfiguration zuordnen. Wenn Sie beispielsweise Ihre Komponententests nicht für Ihren Build "Produktion" erstellen, kann das Build-Projekt diese Einstellung ebenfalls kennen und nicht erstellen, da sie als solche markiert wurden.

Außerdem haben wir XCopy-Drops von der Build-Maschine ausgeführt. Das Skript würde einfach das Kopieren von Inhalten mit dem Namen * .Tests.Dll unterlassen. Es war einfach, hat aber funktioniert.

Joseph Ferris
quelle
1

Ich würde sagen, halte sie getrennt.

Zusätzlich zu den anderen genannten Gründen verzerrt das gemeinsame Vorhandensein von Code und Tests die Testabdeckungszahlen. Wenn Sie über die Abdeckung von Komponententests berichten - Die gemeldete Abdeckung ist höher, da die Tests beim Ausführen von Komponententests abgedeckt werden. Wenn Sie über die Abdeckung von Integrationstests berichten, ist die gemeldete Abdeckung geringer, da bei Integrationstests keine Komponententests ausgeführt werden.

Sebastian K.
quelle
Hängt das nicht von der Technologie ab, mit der die Tests durchgeführt wurden? Ich meine, OpenCover berücksichtigt Codezeilen, die abgedeckt werden, wenn sie von einem Test ausgeführt werden, einschließlich der Zeilen des Tests selbst, sodass Tests, die unerwartete Ausnahmen aufweisen, ebenfalls als unbedeckt gekennzeichnet werden.
Isaac Llopis
0

Ich bin wirklich inspiriert vom Unit-Testing-Framework der Flood NN-Bibliothek von Robert Lopez. Es verwendet ein anderes Projekt für jede einzelne getestete Klasse und verfügt über eine Lösung, die alle diese Projekte enthält, sowie ein Hauptprojekt, das alle Tests kompiliert und ausführt.

Das Schöne ist auch das Layout des Projekts. Die Quelldateien befinden sich in einem Ordner, aber der Ordner für das VS-Projekt befindet sich unten. Auf diese Weise können Sie verschiedene Unterordner für verschiedene Compiler erstellen. Alle VS-Projekte werden mit dem Code ausgeliefert, sodass jeder sehr einfach einige oder alle Komponententests ausführen kann.


quelle
0

Ich weiß, dass dies eine sehr alte Frage ist, aber ich möchte meine Erfahrung dort hinzufügen. Ich habe kürzlich die Gewohnheit, Unit-Tests durchzuführen, von separaten Projekten auf dasselbe geändert.

Warum?

Erstens neige ich sehr dazu, die Struktur des Hauptprojektordners mit dem Testprojekt gleich zu halten. Wenn ich also eine Datei unter Providers > DataProvider > SqlDataProvider.cshabe, erstelle ich in meinen Unit-Test-Projekten die gleiche Struktur wieProviders > DataProvider > SqlDataProvider.Tests.cs

Aber nachdem das Projekt immer größer wird und Sie Dateien von einem Ordner in einen anderen oder von einem Projekt in einen anderen verschieben, wird es sehr mühsam, diese mit Unit-Test-Projekten zu synchronisieren.

Zweitens ist es nicht immer sehr einfach, von der zu testenden Klasse zur Unit-Test-Klasse zu navigieren. Dies ist für JavaScript und Python noch schwieriger.

Vor kurzem habe ich angefangen zu üben, dass ich mit jeder einzelnen Datei, die ich erstellt habe (zum Beispiel SqlDataProvider.cs), eine andere Datei mit dem Suffix Test erstellt, wie zSqlDataProvider.Tests.cs

Am Anfang scheint es, als würde es Dateien und Bibliotheksreferenzen aufblähen, aber auf lange Sicht werden Sie das Moving-File-Syndrom auf den ersten Blick beseitigen und außerdem sicherstellen, dass jede einzelne Datei, die getestet werden soll, eine Paardatei hat mit .TestsSuffix. Sie können einfach in die Testdatei springen (weil sie nebeneinander liegt), anstatt durch ein separates Projekt zu schauen.

Sie können sogar Geschäftsregeln schreiben, um das Projekt zu durchsuchen, eine Klasse zu identifizieren, die keine .Tests-Datei enthält, und diese dem Eigentümer zu melden. Außerdem können Sie Ihrem Testläufer leicht mitteilen, welche .TestsZielklassen er haben soll.

Insbesondere für Js und Python müssen Sie Ihre Referenzen nicht aus einem anderen Pfad importieren. Sie können einfach denselben Pfad der zu testenden Zieldatei verwenden.

Ich verwende diese Praxis für eine Weile und denke, dass es ein sehr vernünftiger Kompromiss zwischen Projektgröße und Wartbarkeit und Lernkurve für Neulinge im Projekt ist.

Teoman Shipahi
quelle
Ich bin nicht einverstanden. Es ist viel besser organisiert, Elemente zu gruppieren, als einzelne Klassen zu testen. Wenn Sie Ihre Anbieter testen; Sie hätten einen IProvider, ISqlProvider und eine MockSqlConnection. In einem Provider-Ordner hätten Sie den Unit Test für jeden Provider. Sie können bei Unit-Tests so tief gehen, aber dann schreiben Sie nur Tests und keinen Code und entfernen möglicherweise sogar den Profi und beginnen, Code zum Testen zu schreiben.
Nick Turner
0

Wie andere geantwortet haben - setzen Sie Tests in separate Projekte

Eine Sache, die nicht erwähnt wurde, ist die Tatsache, dass Sie nur nunit3-console.exegegen .dllDateien laufen können.

Wenn Sie Ihre Tests über TeamCity ausführen möchten, ist dies ein Problem.

Angenommen, Sie haben ein Konsolenanwendungsprojekt. Beim Kompilieren wird eine ausführbare Datei .exean den binOrdner zurückgegeben.

Von dort aus können nunit3-console.exeSie keine in dieser Konsolenanwendung definierten Tests ausführen.

Mit anderen Worten, eine Konsolenanwendung gibt eine exeDatei zurück und eine Klassenbibliothek gibt dllDateien zurück.

Ich habe heute nur ein bisschen davon bekommen und es ist scheiße :(

Kolob Canyon
quelle
0

Ich habe vor kurzem in Docker bereitgestellt. Ich sehe keinen Wert darin, ein separates Projekt zu haben, wenn die Docker-Datei das Verzeichnis / src problemlos kopieren und das Verzeichnis / test verlassen kann. Aber ich bin neu bei dotnet und vermisse möglicherweise etwas.

MikeF
quelle
-2

Separate Projekte, obwohl ich mit mir selbst diskutiere, ob sie den gleichen SVN teilen sollten. Im Moment gebe ich ihnen separate SVN-Repositories, eines mit dem Namen

"MyProject" - für das Projekt selbst

und einer rief an

"MyProjectTests" - für die mit MyProject verknüpften Tests.

Dies ist ziemlich sauber und hat den Vorteil, dass Commits für das Projekt und Commits für die Tests ziemlich getrennt sind. Dies bedeutet auch, dass Sie den SVN des Projekts bei Bedarf übergeben können, ohne Ihre Tests freigeben zu müssen. Dies bedeutet auch, dass Sie Zweigstellen- / Amtsleitungs- / Tag-Verzeichnisse für Ihre Tests und für Ihr Projekt haben können.

Aber ich bin zunehmend geneigt, für jedes Projekt Folgendes in einem einzigen SVN-Repository zu haben.

Mein Projekt
| \ Trunk
| | \ Code
| \ Tests
| \ Tags
| | \ 0.1
| | | \ Code
| | \ Tests
| \ 0.2
| | \ Code
| \ Tests
\Geäst
  \ MyFork
   | \ Code
    \Prüfung

Es würde mich interessieren, was andere über diese Lösung denken.

sampablokuper
quelle
5
Sie sollten keine separaten Commits für Test- und App-Code benötigen. Sie sollten Hand in Hand gehen und Commits würden beides beinhalten, insbesondere wenn * DD-Design verwendet wird.
Eddiegroves