15-mal heruntergeladen
![public class When_no_data_is_entered_for_person
{
static Person sut;
Establish context = () => sut = new Person();
Because of = () => { /* nothing todo because we simply don't set any data */ };
It should_provide_an_error_text_for_BirthDate = () => sut["BirthDate"].ShouldNotBeEmpty();
It should_provide_an_error_text_for_FirstName = () => sut["FirstName"].ShouldNotBeEmpty();
It should_provide_an_error_text_for_LastName = () => sut["LastName"].ShouldNotBeEmpty();
}](https://image.slidesharecdn.com/tddfrtestmuffel-161206104907/85/TDD-fur-Testmuffel-58-320.jpg)
![[TestFixture]
public class PersonValidationTests
{
[Test]
public void Error_text_shall_be_provided()
{
var sut = new Person();
Assert.That(sut["FirstName"], Is.Not.Null);
Assert.That(sut["LastName"], Is.Not.Null);
Assert.That(sut["BirthDate"], Is.Not.Null);
}
}
Sehr leistungsfähiges XUnit Testing Framework.
+ Gut geeignet für Unit und Integrationstests.
+ Wird von vielen gängigen Tools unterstützt.
+ Bietet die meisten Feautres der gängigen
XUnit Frameworks.
+ Ist sehr gut erweiterbar
+ Kann für alle gängigen .Net Plattformen eingesetzt
werden.
o Es wird ein Adapter benötigt um Tests in TFS und
VS ausführen zu können (per NuGet installierbar)](https://image.slidesharecdn.com/tddfrtestmuffel-161206104907/85/TDD-fur-Testmuffel-81-320.jpg)
![public class WhenPersonSelectionIsShown : Specifies<PersonSelectionViewModel>
{
public override void Given()
{
this.AvailablePersons = new List<Person>(){new Person()};
var repository = this.GetInstance<IRepository>();
A.CallTo(() => repository.GetPersons()).Returns(this.AvailablePersons);
}
public override void When()
{
this.SUT.OnShow();
}
[Test]
public void ThenAllAvailablePersonsAreShown()
{
Assert.AreEqual(this.AvailablePersons.Count(), this.SUT.Persons.Count());
}
public IEnumerable<Person> AvailablePersons { get; set; }
}
Leichtgewichtige Erweiterung von NUnit und MS Test
um Tests in BDD Stil zu verfassen.
+ Bietet Automocking.
+ Sehr umfangreich und leicht erweiterbar.
+ Erlaubt lesbarere Tests.
+ Ist gut erweiterbar
+ Leichtgewichtig.
o bietet vergleichsweise wenige Features moderner
BDD Frameworks.](https://image.slidesharecdn.com/tddfrtestmuffel-161206104907/85/TDD-fur-Testmuffel-82-320.jpg)
Hochgeladen vonHendrik Lösch
TDD für Testmuffel
Das Dokument behandelt verschiedene Aspekte der Softwareentwicklung, insbesondere im Hinblick auf Testmethoden und Frameworks. Es werden Prinzipien für Unit-Tests sowie deren Unterscheidung von anderen Testarten beschrieben, einschließlich Bezug auf Performance und Validierung. Außerdem wird auf verschiedene Tools und Methoden eingegangen, wie z.B. IoC-Container, ORM und Testautomatisierung, um die Effizienz und Qualität der Softwareentwicklung zu steigern.
TDD für Testmuffel
- 3.
- 5.
- 7.
- 9.
- 10. Benutzersicht Architektursicht Speichern AnbindungUI Anbindung Persistenz Geschäftslogik DB Extern System-Tests
- 11. Benutzersicht Architektursicht Speichern AnbindungUI Anbindung Persistenz Geschäftslogik DB Extern System-Tests
- 13.
- 14. Benutzersicht Architektursicht Speichern AnbindungUI Anbindung Persistenz Geschäftslogik DB Extern System-Tests Unit-Tests
- 15.
- 16.
- 17.
- 20.
- 23.
- 26. UI Business Layer Data/Service Layer O/RMapper UI Business Layer Data/Service Layer
- 27.
- 29. Unit tests runfast. If they don't run fast, they aren't unit tests. Other kinds of tests offen masquerade as unit tests. A test is not a unit test if: 1. It talks to a database. 2. It communicates across a network. 3. It touches the file system. 4. You have to do special things to your environment (such as editing configuration files) to run it. Tests that do these things aren't bad. Often they are worth writing, and you generally will write them in unit test harnesses. However, it is important to be able to separate them from true unit tests so that you can keep a set of tests that you can runfast whenever you make changes.
- 31.
- 32.
- 36. hohe Ergebnisgenauigkeit Geringe Geschwindigkeit jeTest Hohe Testanzahl Geringer (Anfangs)aufwand Hohe Ausführungsgeschwindigkeit je Test Geringe Testanzahl Hoher (Anfangs)aufwand Geringe Ergebnisgenauigkeit
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51. Problem verstehen Grobdesign („Architektur Vision“) Automatisierung • Build • Deployment •End-To-End Tests Produkt- inkrement Produkt Release
- 52.
- 53.
- 54.
- 56.
- 57.
- 58. public class When_no_data_is_entered_for_person { staticPerson sut; Establish context = () => sut = new Person(); Because of = () => { /* nothing todo because we simply don't set any data */ }; It should_provide_an_error_text_for_BirthDate = () => sut["BirthDate"].ShouldNotBeEmpty(); It should_provide_an_error_text_for_FirstName = () => sut["FirstName"].ShouldNotBeEmpty(); It should_provide_an_error_text_for_LastName = () => sut["LastName"].ShouldNotBeEmpty(); }
- 59.
- 63. Specflow Gherkin MS Test XUnit.Net NUnit Mspec … XUnit UITesting Framework Silenium WatiN Coded UI Tests White … Given When Then C#
- 64.
- 67.
- 68. Quelle: Dr. ElmarJürgens, CQSE 4 3 2 1 Keine Defizite Keine Defizite in geändertem Code Keine neuen Defizite Egal
- 69.
- 72. CI Umgebung für.Net Projekte. + Sehr einfach und übersichtlich. + Für Opensource kostenlos. + Gute Übersicht über die Ergebnisse und den Verlauf. + Gute Zusammenarbeit mit Github. o Geringe Anpassungmöglichkeiten. - Ausführung und Dokumentation automatisierter Tests eher rudimentär.
- 73. Beliebtester Hostingdienst fürOpensource Projekte auf Basis von Git. + Sehr große Community. + Für Opensource kostenlos. + Wird von vielen Diensten unterstützt. o Private Repositories kostenpflichtig. - UI ist bedingt nutzerfreundlich.
- 74. Vergleichsweise neue GUIfür Git die versucht andere Wege der Darstellung zu gehen. + Plattformunabhängig + Gute Abbildung der gängigen Arbeitsabläufe. + Auch komplexe Aufgaben können über die UI gelöst werden. + kostenlos. + Gute Darstellung der Dateihistorie und Versionsvergleiche. o Wird bei größeren oder vielen Projekten träge. o Benötigt etwas Einarbeitungszeit.
- 75. Framework zur Erstellungmodularer Applikationen auf Basis diverser Xaml UI Technologien. Eignet sich besonders für komplexe Großanwendungen. + Bootstrapping der Anwendung. + Regionhandling & Navigation. + ViewModel Locator. + Integration von DI Frameworks. + Modulehandling / Plugins. + Infrastruktur für Behaviours. + DelegateCommands. + Messagebus aka EventAggregator. + Verschiedene Basisklassen für ViewModels. o Bei Kleinstanwendungen eher schwergewichtig.
- 76. IoC Container dersehr gut in Kombination mit Prism zusammen arbeitet. + Es gibt nur einen Typen bei dem Typen registriert und aufgelöst werden. + Diverse Möglichkeiten um Einfluss auf die Lebenszeit von Instanzen zu nehmen. + XML Konfiguration möglich. + Automatische Registrierung bestimmter Typen einer Assembly möglich. + Einsatz aspektorientierter Programmierung möglich. o Es gibt weitaus schnellere IoC Container. o AOP wird zur Laufzeit vorgenommen und ist dadurch vergleichsweise langsam. - Wird aktuell nicht sehr aktiv gepflegt.
- 77. Umfangreicher IoC Containerder sehr gut mit anderen Frameworks kombiniert werden kann. + Vergleichsweise schnelle Auflösung von Typen. + Sehr umfangreiche Möglichkeiten um Einfluss auf die Lebenszeit von Instanzen zu nehmen. + Automatische Registrierung bestimmter Typen einer Assembly möglich. + Für diverse .Net Plattformen verfügbar. + Konfiguration per XML und Json möglich. + Eigene Modulinfrastruktur. + Hervorragende Dokumentation und Pflege. o Etwas aufwändig mit Prism zu verwenden. o Registrierung und Auflösung von Typen geschieht über unterschiedliche Klassen.
- 78. public IQueryable<Place> GetPlaces(intcategoryId) { var places = this.dataBase.CategoryPlace .Where(x => x.CategoryId == categoryId); return this.dataBase.Place.Where(x => places .Any(p => p.PlaceId == x.Id)); } public Language GetLanguage(int languageId) { return this.dataBase.Language.Find(languageId); } Sehr umfangreicher objektrelationaler Mapper für diverse .Net Plattformen. + Sehr einfach und intuitiv zu nutzen. + Gute Konfigurationsmöglichkeiten. + Sowohl für kleine als auch große Projekte geeignet. + Sehr aktive Community. o Einsatz mit Nicht Microsoft Datenbanken gelegentlich schwierig. o Einfachheit täuscht darüber hinweg wie schnell man Performanceschwachstellen entwickeln kann. - Verwirrende Releasestrategie der unterschiedlichen Versionen.
- 79. Werkzeug mit demautomatisierte Tests kontinuierlich während der Programmierung ausgeführt werden. + Sehr schnelle Feedbackzyklen. + Volle Integration ins Visual Studio. + Sehr klare Darstellung der Testabdeckung und möglicher Fehlerstellen. + Out-of-the-box Unterstützung für MS Test, NUnit, XUnit.net + Umfangreiche Konfigurationsmöglichkeiten. o Nicht für Integrationstests geeignet. o Funktionale UI - Zugriffe auf das Dateisystem aus Tests heraus führen häufig zu Fehlern.
- 80. Plugin für VisualStudio um XAML Code automatisch zu formatieren. + Sehr einfach und leichtgewichtig. + Xaml Dateien sind besser lesbar. o Reformatierung des Codes kann zu Problemen bei Code-Reviews führen. - Sehr große Dateien (>10k Zeilen) können das VS zum Absturz bringen.
- 81. [TestFixture] public class PersonValidationTests { [Test] publicvoid Error_text_shall_be_provided() { var sut = new Person(); Assert.That(sut["FirstName"], Is.Not.Null); Assert.That(sut["LastName"], Is.Not.Null); Assert.That(sut["BirthDate"], Is.Not.Null); } } Sehr leistungsfähiges XUnit Testing Framework. + Gut geeignet für Unit und Integrationstests. + Wird von vielen gängigen Tools unterstützt. + Bietet die meisten Feautres der gängigen XUnit Frameworks. + Ist sehr gut erweiterbar + Kann für alle gängigen .Net Plattformen eingesetzt werden. o Es wird ein Adapter benötigt um Tests in TFS und VS ausführen zu können (per NuGet installierbar)
- 82. public class WhenPersonSelectionIsShown: Specifies<PersonSelectionViewModel> { public override void Given() { this.AvailablePersons = new List<Person>(){new Person()}; var repository = this.GetInstance<IRepository>(); A.CallTo(() => repository.GetPersons()).Returns(this.AvailablePersons); } public override void When() { this.SUT.OnShow(); } [Test] public void ThenAllAvailablePersonsAreShown() { Assert.AreEqual(this.AvailablePersons.Count(), this.SUT.Persons.Count()); } public IEnumerable<Person> AvailablePersons { get; set; } } Leichtgewichtige Erweiterung von NUnit und MS Test um Tests in BDD Stil zu verfassen. + Bietet Automocking. + Sehr umfangreich und leicht erweiterbar. + Erlaubt lesbarere Tests. + Ist gut erweiterbar + Leichtgewichtig. o bietet vergleichsweise wenige Features moderner BDD Frameworks.
- 83. Sehr einfaches undleicht verständliches Mocking Framework welches einen umfassenden Einsatz von Interfaces verlangt. + Sehr einfach nutz und erlernbar. + Tests mit FakeItEasy sind sehr gut lesbar. + Sehr aktive Community. + Weitreichend von anderen Frameworks unterstützt. + Sehr gute Dokumentation. - Kann keine konkreten Typen mocken. - Kann keine statischen Typen mocken.
- 84. public class Person { publicstring Name { get; set; } public string LastName { get; set; } } public class HelloFiller { public void FillPerson() { var pFiller = new Filler<Person>(); pFiller.Setup() .OnProperty(p => p.Name).Use("John") .OnProperty(p => p.LastName).Use(new RealNames(NameStyle.LastName)); var filledPerson = pFiller.Create(); } } Framework zur automatisierten Generierung von Daten. + Sehr einfach verständlich. + Sehr umfangreich. + Bietet Implementierungen für viele Standardfälle. + Gute Plugin-Infrastruktur um selbst Erweiterungen vorzunehmen. + Gute Dokumentation + Aktive Community o Aufwändige Konfiguration führen zu repetitivem Code. - Keine direkte Integration in Testingframeworks.
- 85. Bietet verschiedenste Möglichkeitenum Quellcode zu analysieren, refaktorisieren und zu verbessern.