Übungen Dependency Injection und Integrationstests

Schritt 1: Laden Sie das Projekt Download Spring 4 Version herunter

 

Schritt 2: Importieren Sie das Projekt direkt in Eclipse

 

Schritt 3: Den JUnit DependencyInjectionTest ausführen

 

Schritt 4: Spring Objekt-Netz in XML Konfiguration
(/META-INF/core-context.xml) einarbeiten

Erstellen Sie für das im Modell unten skizzierte Objektnetz eine Spring XML Konfiguration.

Siehe dazu Spring Dokumentation: hier

 

Schritt 5: Spring Objekt Netz als Java Konfiguration anlegen

Überführen Sie die XML Konfiguration in eine Java basierte Konfiguration.

Anmerkung: Dazu kann der Test ClassConfigurationTest genutzt werden.

Schritt 6: Top-Down Integration 

(ShoppingController - BasarService - SimplePositionRepository - SimpleUserRepository)

Siehe auch Mockito Doku:
http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html

Integrationstests Teil II und TDD

Folien und Übungen

• Folien

Inhalt

• Wiederholung Integrationstests
• Integrationsstrategien
• Test Driven Development
• Black-Box Testverfahren

Lernziele (Fragen zur Vorlesung) 

• Was sind die Testziele beim Integrationstest?
• Was ist der Unterschied zwischen White-Box und Black-Box Testing?
• Nennen Sie drei typische Integrationsfehler.
• Welche Integrationsstrategien kennen Sie? Welche Vor- und Nachteile haben diese?
• Was ist der Unterschied zwischen White-Box und Gray-Box Testing?
• Aus welchen Schritten besteht der Prozess zur Testgetriebene Entwicklung (Test Driven Development Prozess)?
• Welche Vorteile bietet die Testgetriebene Entwicklung?
• Was sind Äquivalenzklassen?

TDD - Werkzeug:

•  Continuous Testing plugin for Eclipse https://infinitest.github.io/

Literatur

• Test Driven Development. By Example - Kent Beck 2002
• xUnit Test Patterns: Refactoring Test Code - Gerard Meszaros 2007
• Andreas Spillner - Basiswissen Softwaretest - 2005
• Documentation Spring Testing Framework - http://static.springsource.org/spring/docs/current/spring-framework-reference/html/testing.html#integration-testing
• Integration Testing with Spring - http://www.infoq.com/presentations/system-integration-testing-with-spring

Musterlösung Übung zu Test-Doubles

Dependency Injection (DI) und Integrationstests

Folien

• Folien

Inhalt

• Wiederholung Statische-Tests
• Refactoring
• Dependency Injection (Einführung in Spring u. Spring Boot)
• Integrationstests
• Integrationsstrategien

Lernziele (Fragen zur Vorlesung) 

• Was sind die Testziele beim Integrationstest?
• Was verstehen Sie unter äußere & innere Software-Qualität?
  (Ordnen Sie die Attribute der ISO-9126 entsprechend zu.)
• In welche Teststufen können Integrationstests aufgeteilt werden?
• Was ist der Unterschied zwischen White-Box und Black-Box Testing?
• Was versteht man unter einem unabhängigen Tester?
• Nennen Sie drei typische Integrationsfehler.
• Welche Integrationsstrategien kennen Sie? Welche Vor- und Nachteile haben diese?
• Wer führt den Integrationstest durch?
• Wie schreibt man Komponenten, bei denen die damit verbundenen Komponenten gut austauschbar sind?

Literatur

• xUnit Test Patterns: Refactoring Test Code - Gerard Meszaros 2007
• Andreas Spillner - Basiswissen Softwaretest - 2005

Übung zu Test-Doubles und statischen Tests

Aufgabe zu Mocking und Stubbing

Schritt 1: Laden Sie das Projekt swqs.mocking.keywords.analyzer.zip herunter.

Schritt 2: Importieren Sie das Projekt direkt in Eclipse

Schritt 3: Machen Sie die Klasse KeyWordAnalyzer testbar ohne die  Existenz einer Implementierung des Interface KeyWordRepository vorauszusetzen. 

Schritt 4: Schreiben Sie für die Klasse KeyWordAnalyzer einen JUnit Test 

Nutzen Sie dazu Stubbing und Mocking Möglichkeiten des Werkzeugs Mockito.

Anmerkung: Eine ausführlich Dokumentation zu Mockito finden Sie unter:
http://mockito.github.io/mockito/docs/current/org/mockito/Mockito.html

Schritt 5: Prüfen Sie ob Sie alle Anweisungen der Klasse KeyWordAnalyzer mit Ihrem Test geprüft haben.

Aufgabe zu Statischen Testverfahren

Schritt 1: Einrichten des Sonar Servers auf Ihrem System

Dazu laden Sie sich den Sonar Server in der Version 5.2 herunter von der Projektseite unter:

http://www.sonarqube.org/downloads/

Entpacken Sie den Server und starten Sie den Server über das Skript:
"sonarqube-5.2/bin/windows-x86-32/StartSonar.bat" 
Anmerkung: Linux und Mac OSX Nutzer verwenden die entsprechenden Skripte unter Mac OSX z.B. "sonarqube-5.2/bin/macosx-universal-64/sonar.sh console"

Anschließend können Sie unter der URL "http://localhost:9000/" den Sonar Server aufrufen. Für den Login können Sie den Nutzer mit dem Nutzernamen: admin und dem Passwort: admin nutzen.

Schritt 2: Laden Sie das Projekt swqs.statictests.tennis herunter.

Schritt 3: Importieren Sie das Projekt direkt in Eclipse

Schritt 4: Tests ausführen und Ergebnisse auf den Sonar Server übertragen

Öffnen Sie eine Kommandozeile und wechseln in den Ordner des Projekts swqs.statictests.tennis.

Dort rufen Sie das Build Werkzeug Gradle wie folgt auf "gradlew.bat sonarqube" (unter Linux und MacOSX ./gradlew sonarqube). Nach dem erfolgreichen Build wechseln Sie in den Sonar Server dort finden Sie nun ein entsprechendes Projekt mit den Ergebnissen der statischen Tests.

Schritt 5: Refactoring mit statische Tests

Versuchen Sie durch Refactorings die Fehler und Probleme die der Sonar Server anzeigt zu lösen. Anschließend können Sie über einen erneuten Gradle Build prüfen ob Ihre Maßnahmen zu einer Verbesserung geführt haben.

Statische Testverfahren

Download

Folien

Lernziele (Fragen zur Vorlesung)

• Wie können Code Reviews durchgeführt werden? 
• Welche Review Verfahren kennen Sie?
• Welches Review Verfahren bietet sich für Code Reviews an?
• Welche Java Namenskonventionen kennen Sie?
• Wie können die Java Namenskonvention geprüft werden?
• Welche Codemetriken sollten beachtet werden?
• Was versteht man unter dem McCabe-Maß? Wie berechnet es sich? Wie nennt man es noch?
• Was versteht man unter dem Begriff Refactoring?
• Aus welchen Schritten besteht der Prozess für ein Refactoring?

Links

• Tool um Code Konvention zu prüfen - http://checkstyle.sourceforge.net/
• Eclipse Plugin für Checkstyle - http://eclipse-cs.sourceforge.net/
• Eclipse Plugin für Metrics - http://metrics.sourceforge.net/
• McCabe Paper - http://www.literateprogramming.com/mccabe.pdf
• Findbugs - http://findbugs.sourceforge.net/
• javancss Werkzeug um Metriken für java code zu bestimmen - http://www.kclee.de/clemens/java/javancss
• Code Conventions for the Java Programming Language - http://www.oracle.com/technetwork/java/codeconv-138413.html

Musterlösung Übung Komponententests und Testabdeckung

Hier finden Sie eine Musterlösung in Form von zwei JUnit Tests für die erste Übungsaufgabe zum Thema Komponententests, geprüft wird die Klasse Quicksort:
Link zur Musterlösung

Übungsaufgabe zu Komponententests

Für die Komponente "quicksort" im Java Package "swqs.quicksort" soll ein Komponententest (Unit-Test) geschrieben werden. Die Komponente umfasst alle Klassen im Java Package.

Schritt 0: Importieren des Beispiel-Projekts in Eclipse

Dazu laden Sie sich die ZIP Datei herunter: DOWNLOAD

Anschließend entpacken Sie das Archive und rufen das folgende Gradle Kommando auf:

  gradlew.bat eclipse



(Linux und OSX Benutzer können das Kommando wie folgt aufrufen ./gradlew eclipse)

Nun können Sie das Projekt in Eclipse importieren als existierendes Projekt.

Hinweis für den Import in Eclipse:
Für den Import die Funktion File > Import aufrufen.

 Das Verzeichnis mit dem entpackenten Projekt (ZIP) auswählen und den Finsh Button klicken.

Schritt 1: Erstellen einer Unit Test Klasse 

Geben Sie der Klasse den Namen QuicksortTest geprüft werden soll die Komponente Quicksort, die Test-Klasse sollte im Source-Folder "src/test/java" abgelegt werden

Schritt 2: Schreiben eines Tests zum Sortieren des folgenden Arrays:

  new Integer[]{5, 6, 3};

Schritt 3: Markieren Sie die 4 Phasen in Ihrer Unit Test Klasse

Nutzen Sie dazu einfache Java Kommentare.

Schritt 4: Messen der Abdeckung mittels Gradle oder Eclipse Plugin. 

Dazu kann das Gradle Skript wie folgt aufgerufen werden:

  ./gradlew.bat

Der Report mit der Abdeckung kann dem folgenden Ordner entnommen werden:
swqs.quicksort\build\reports\tests\index.html

Oder Sie installieren ein entsprechendes Eclipse Plugin z.B. EclEmma (http://eclemma.org/)

Schritt 5: Erstellen eines Tests zum Sortieren des folgenden Arrays:

  new String[]{"xy", "aa", "bb"};

Schritt 6: Identifizieren Sie weitere Testfälle 

Versuchen Sie 100 % Anweisungsabdeckung zu erreichen und 100 % Zweigabdeckung.

Optional Schritt 6: FEST Asserts 

Nutzen Sie anstelle der JUnit Assertion API die FEST asserts
siehe dazu https://github.com/alexruiz/fest-assert-2.x/wiki/Using-fest-assertions

Hinweis - Eclipse Tooling für Coverage

Um Coverage in Eclipse messen zu können müssen Sie eine Erweiterung installieren z.B. Code Cover oder EclEmma. Die Links zu den Eclipse Update Sites finden Sie hier.

Installieren von Code Cover in Eclipse
(siehe http://codecover.org/documentation/install.html)
Name: CodeCover Update Site
URL:  http://update.codecover.org/

Installieren von EclEmma Eclipse Plugin
(siehe auch http://www.eclemma.org/)
Name: EclEmma
URL:  http://update.eclemma.org/ 

Komponententests und Testabdeckung

Download Folien (als PDF) hier.

Lernziele:

• Beschreiben Sie die Phasen in die ein Unit-Test aufgeteilt werden kann.
• Welchen Teil einer Anwendung testet ein Komponententests?
• Welche Qualitätskriterien sollten bei Komponententests (Modultests) geprüft werden?
• Was bezeichnet der Begriff Testabdeckung?
• Warum ist eine vollständige Testabdeckung i.d.R. nicht möglich?
• Welche Methoden zur Bestimmung der Testabdeckung für White-Box (bzw. Gray-Box) Tests kennen Sie?
• Wie bestimmen Sie die mögliche Anzahl der Pfade in einer Schleife? 
• Was sind "Test Doubles" und wozu braucht man sie?
• Welche unterschiedlichen Typen von "Test Doubles" kennen Sie?
• Wann sollte man ein Mocking Werkzeug wie Mockito zum testen einsetzten?

Werkzeuge Links

• JUnit - http://www.junit.org/
• Mockito - https://code.google.com/p/mockito/
• EclEmma - http://eclemma.org
• Code Cover - http://codecover.org/

Einführung Software Qualitätssicherung

Download

• Folien als PDF

Lernziele

• Was ist Software-Qualität?
• Was sind die Kriterien guter Software?
• Wie kommt man zu guter Software?
• Was versteht man unter konstruktive und analytischer Qualitässicherung?
• Unterscheiden Sie die Begriffe Fehlerwirkung, Fehlerzustand, Fehlhandlung.
• Was ist der Unterschied zwischen Testen und Debuggen?
• Beschreiben Sie das Vier Phasen Test Muster. Welche Phasen gibt es und wozu dienen sie?
• Wozu setzt man bei JUnit die Methoden setUp() und tearDown() ein?
• Wie muss man vorgehen, um aus einer "normelen" Klasse eine Testklasse zu machen?
• Welche Java Sprachfunktionen werden in JUnit 4 verwendet um eine Methode als Test zu markieren?

ISO-9126 Attribute

ISO-25010 Attribute

Links

• JUnit Homepage - http://www.junit.org/
• Linksammlung zu bekannten Software Fehlern -  http://www5.in.tum.de/lehre/seminare/semsoft/unterlagen_02/

Blog Software-Qualitätssicherung

Herzlich Willkommen zur Vorlesung Softwarequalitätssicherung. Hier auf diesem Blog finden Sie alle Informationen (Folien, Hinweise zu Bücher, Links, etc.) zu der SWQS Vorlesung des WS1516. Es wird zur jeder Vorlesung ein Blogeintrag geben über den ich Ihnen alle Unterlagen zur Vorlesung bereitstelle.

Am besten Sie abonnieren einfach den News-Feed dann bekommen Sie immer mit wenn es was neues rund um die Vorlesung gibt.

Viele Grüße

Christian Baranowski