29. Unit tests run fast. 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.
36. hohe Ergebnisgenauigkeit
Geringe Geschwindigkeit
je Test
Hohe Testanzahl
Geringer (Anfangs)aufwand
Hohe Ausführungsgeschwindigkeit
je Test
Geringe Testanzahl
Hoher (Anfangs)aufwand
Geringe Ergebnisgenauigkeit
58. 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();
}
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ür Opensource
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 GUI fü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 Erstellung modularer 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 der sehr 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 Container der 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(int categoryId)
{
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 dem automatisierte 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 Visual Studio 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]
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)
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 und leicht 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
{
public string 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.