Logo der codecentric AG, einem in Deutschland führenden IT-Consulting Unternehmen

Logo der codecentric AG einem in Deutschland führenden IT-Consulting Unternehmen

Cloud-Native

Data & Machine Learning

Generative KI

IT-Security

Produktentwicklung

Weitere Leistungen...

Leistungen

Arbeitsweise

Projekte

Berlin

Bielefeld

Dortmund

Erfurt

Frankfurt am Main

Hamburg

Karlsruhe

Leipzig

München

Münster

Nürnberg

Solingen

Stuttgart

Standorte

Blog

Softwerker

Fachmedien

Webinare

Events

Wissens-Hub

Unsere Kultur

Kultur & Karriere Podcast

Deine Entwicklung

Jobs

Karriere

Über uns

Aktuelles

Kontakt

Alle Standorte

Du hast Fragen oder möchtest dich mit mir austauschen? Gern – trag einfach deine Kontaktdaten ein.

Contact Us | Sub-Navi-Kontakt oder Zero Search Hits

Kontakt aufnehmen

Marketing & Community Management

Konntest du keine Einträge zu deinem Thema finden?  

STANDORT-TEAM

codecentric Bielefeld

Mitten in der Bielefelder Altstadt bauen wir passgenaue Software. Agile Werte und Zusammenarbeit auf Augenhöhe sind dabei Basis unserer täglichen Arbeit. 

codecentric Team Bielefeld

Willkommen im Team Bielefeld

<p>Typischerweise sind bei Hackathons viele Soft- und Hardware-Entwickler zu finden, die innerhalb eines begrenzten Zeitraums versuchen, kreative und ungewöhnliche Lösungen in Form von Code und ersten Prototypen für vorher definierte Challenges zu erarbeiten. Beim BIE City Hackathon (<a href="http://www.bie-city.de" target="_blank">www.bie-city.de</a> ) der Open Innovation City Bielefeld und dem Digitalisierungsbüro der Stadt Bielefeld wurden davon abweichend auch insbesondere Nicht-Techies eingeladen, um die kollektive Intelligenz einer Stadt zu nutzen – zur Generierung und Findung von Ideen für die Herausforderungen einer Stadt im neuen Alltag mit COVID-19. Als Teilnehmerin und Mentorin konnte ich einige spannende Lösungsansätze in ihrer Entstehung begleiten. Die zu lösenden Probleme kamen aus den Bereichen Breitensport, Einzelhandel, Kunst und Kultur, öffentlicher Raum, Mobilität und Gastronomie.</p><h2>Die Challenge</h2><p>Mein eigenes Team hat die Herausforderung der Erkennung und Vermeidung von überfüllten Plätzen und einem verantwortungsvollen Miteinander bearbeitet. Überfüllte Plätze sind in der aktuellen Pandemie- und in den alltäglichen Situationen eine besondere Herausforderung für die Stadt und ihre BürgerInnen. Aktuell steigert ein hohes Menschenaufkommen auf begrenztem Raum das Ansteckungsrisiko mit COVID-19. Zudem wird aber auch die Bevölkerungszahl in Bielefeld über Corona hinaus zunehmen – der Platz der Stadt bleibt aber begrenzt, was auch eine generelle Verringerung der Aufenthaltsqualität an öffentlichen Plätzen zur Folge haben kann.</p><h2><b>Unsere Lösung</b></h2><p>Unsere Lösung überzeugte die Jury und zeichnete sie als eine der beiden Gewinner-Lösungen aus. Neben der Freude über das Preisgeld haben wir die Hoffnung, dass die Lösung, die wie folgt aussieht, zeitnah realisiert wird:</p><ul><li> Wir zählen Personen im Bereich der Innenstadt, sowie an relevanten Orten und Verkehrsknotenpunkten (Haltestellen ÖPNV, Marktplätze, etc.) mittels Sensorik.</li><li> Die Daten zur Personendichte werden dann in Form einer Heatmap mit zusätzlichen Informationen veröffentlicht, z. B. auf den offiziellen Seiten der Stadt Bielefeld (<a href="http://www.bielefeld.de" target="_blank">www.bielefeld.de</a> ) und Bielefeld Marketing (<a href="http://www.bielefeld.jetzt" target="_blank">www.bielefeld.jetzt</a> ). Dabei wird das Personenaufkommen mittels Ampelsystem abgebildet und es werden noch nicht so stark besuchte Alternativen (Orte, Routen, Veranstaltungen) vorgeschlagen, aber auch Prognosen über die zukünftige Entwicklung der Personenzahlen ausgegeben.</li><li>Zusätzlich werden die Informationen an relevanten Orten mit Displays zur Verfügung gestellt und die Daten zu überfüllten Plätzen werden auch in der App von moBiel, dem Anbieter des öffentlichen Nahverkehrs in Bielefeld, beim Suchen nach Verkehrsverbindungen angezeigt.</li></ul><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/1c84f5JmQF6ezVdvcRiC"><img src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/1c84f5JmQF6ezVdvcRiC" alt="bie city hackathon" width="455" height="304" /></a> <i>Foto der Team-Leiter der beiden Sieger-Teams: rechts Helen Bielawa vom Team Sport, links Meike Wocken. (Foto: Open Innovation City).<br /> </i></p><h2><b>Umsetzung </b></h2><p>Generell basiert der Ansatz auf der Nutzung eines (inner)städtischen LoRaWans, welches die Sensoren zur Zählung der Menschen verbindet. LoRaWAN steht für <b>Lo</b>ng <b>Ra</b>nge <b>W</b>ide <b>A</b>rea <b>N</b>etwork und ist eine energieeffiziente Funktechnologie für die Datenübertragung insbesondere von Sensoren, Zählern, oder anderen Messinstrumenten. Die reinen Zähldaten werden über ein Gateway des LoRaWans ans Backend übermittelt und stehen dort mittels Open Data API zur Verfügung, um z.B. dann auf den Webseiten in Form einer Heatmap dargestellt zu werden.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/cWOrw5xOR8yrpDU7fMfc"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/cWOrw5xOR8yrpDU7fMfc" alt width="371" height="209" /></a> </p><p>Aber wie zählen Sensoren Personen? Wir als Menschen können das durch einfache Beobachtung feststellen, ob es sich um ein hohes Menschenaufkommen handelt. Für unseren Prototypen zur Umsetzung der Lösung haben wir uns für den Einsatz einer Kamera entschieden, die erkennen soll, ob viele Menschen auf einem Platz zusammen kommen. D.h. der Sensor besteht aus einem Mikrocontroller (z. B. Raspberry Pi) plus Kamera. Auf dem Mikrocontroller läuft dann eine lokale Bilderkennung (KI-basiert), die Fußgänger, Radfahrer, Kinderwagen etc. erkennt und zählt.</p><p>Wichtig ist bei diesem Einsatz: Die Kamera speichert keine Bilder und gibt auch keine Bilder für die Auswertung weiter. Es ist keine Anbindung an das Internet oder eine Cloud erforderlich. Die Bilder werden sofort lokal ausgewertet und dabei analysiert die KI nur die einzelnen Pixel und deren Farbverläufe im Bild hinsichtlich bekannter Formen, die Menschen, Radfahrern oder Kinderwagen ähneln. Daher muss es bei dieser Lösung keine Datenschutzbedenken geben. Die einzigen Daten, die weitergegeben werden, sind die reinen Zählstände der erkannten Objekte und diese Datenweitergabe ist LoRaWan-basiert. Neben der Kameratechnik kann aber auch andere Sensortechnik zum Erkennen von Menschenmengen genutzt werden, beispielsweise Infrarot, Paxcounter oder Lichtschranken.</p><h2>Open Data</h2><p>Uns war es wichtig herauszustellen, dass unsere Lösung auch über die Corona-Zeit hinaus einen Mehrwert liefern wird. Wir legen viel Wert auf das Open-Data-Konzept, dass die Daten von jedermann verwendet werden können. Unsere Vision ist es, dass die Daten zu einer stärkeren Bürgerbeteiligung in der Stadtentwicklung führen werden, da transparent für alle Gruppen in der Stadt dargestellt wird, wie sich die Mobilität von Menschen ändert, aber auch wie Plätze angenommen werden. Somit können diese Daten (politische) Argumente liefern, mehr Platz für Menschen zu schaffen, z. B. durch die Sperrung von Straßen. Auch Geschäftsmodelle werden sich mithilfe dieser Daten ändern können, z. B. neue Angebote im Nahverkehr, dass beispielsweise der Einsatz von Bussen und Bahnen unter Berücksichtigung der wartenden Personen an den Haltestellen passiert.</p><p><a href="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/oATZ8gTQat6Et8SRTuhg"><img loading="lazy" src="https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/oATZ8gTQat6Et8SRTuhg" alt="bie city hackathon" width="434" height="245" /></a> </p><h2>Die Orga des BIE City Hackathon</h2><p>Es war ein hundertprozentiger Remote-Hackathon, wobei neben dem Organisatoren-Team aber auch weitere Teilnehmer im Pioneers Club gehackt haben, dem Coworking Space, in dem auch das codecentric-Team Bielefeld sitzt. Dort saßen wir auf Distanz in den unterschiedlichen Konferenzräumen verteilt und haben gemeinsam mit weiteren remote arbeitenden Teammitgliedern an unseren Lösungen gearbeitet. Die Kooperation mittels Slack, Miro-Board und Zoom-Sessions hat sehr gut geklappt. Auf die zu erwartende hohe No-Show-Rate einer Remote-Veranstaltung hat das Orga-Team schnell und gut reagiert und hat die Teams passend zusammengestellt.</p><p>Es wäre schön, wenn diese Lösung über den Hackathon hinaus weiterverfolgt würde und die Hackathon-Organisatoren Open Innovation City Bielefeld und das Digitalisierungsbüro der Stadt Bielefeld dafür Sorge tragen würden, dass nächste Schritte in Richtung Umsetzung gemacht werden. Vielen Dank an die Organisatoren für den Hackathon und an mein Team Kim Simon Kreutz, Jürgen Große-Ophoff und Lill Bretz für die tolle Zusammenarbeit!</p>

BIE Spotty – unsere Lösung beim BIE City Hackathon

Die Bedeutung von künstlicher Intelligenz wächst in der heutigen Welt. Doch wie funktioniert KI? Es hat zumindest nichts mit Magie zu tun – auch wenn KI gerne damit assoziiert wird. 

Normalerweise beantworte ich diese Frage ausführlich bei uns im IT Consulting unseren Kunden und helfe ihnen dabei, die Potenziale der künstlichen Intelligenz zu erschließen. Doch aufgrund der wachsenden Relevanz von KI sowohl in der Arbeitswelt als auch der Gesellschaft bin ich der Ansicht, dass KI und Datenkenntnisse mittlerweile zu den grundlegenden Fähigkeiten gehören, die jeder Mensch in der heutigen Welt beherrschen sollte. Insbesondere junge Menschen leben in einem Technologie-geprägten Alltag (nur ein kleiner Auszug):

- Ihre Welt in den sozialen Medien ist gesteuert durch Empfehlungsalgorithmen 
- Texte formulieren sie mithilfe von ChatGPT
- Für den schnellsten Weg von A nach B wird ein online Routing-Planer befragt, um zu entscheiden, ob das Ziel zu Fuß, mit dem Rad oder mit ÖPNV optimal zu erreichen ist.

Im Januar 2024 habe ich daher einmal eine andere Rolle eingenommen und war nicht als IT Consultant unterwegs, sondern stand vor einer 12. Klasse des beruflichen Gymnasiums mit Schwerpunkt Betriebsinformatik am [Berufskolleg Werther Brücke](https://bkwb.de) in Wuppertal. In einem zweistündigen Workshop habe ich ein Grundverständnis für künstliche Intelligenz vermittelt. Schülerinnen und Schülern sollten verstehen, in welchen Bereichen KI Mehrwerte stiften kann, aber auch Risiken verstehen. Die Klasse kannte bereits Algorithmen und hatte den Begriff Machine Learning kennengelernt, doch es fehlte ihr der Zusammenhang und auch die Unterscheidung zwischen den drei Begriffen Algorithmus, Machine Learning und künstliche Intelligenz. 

**Was ist eine künstliche Intelligenz?**

Es war spannend, diese Frage durch Schülerinnen und Schüler beantworten zu lassen und zu sammeln. Anschließend hatten wir eine gemeinsame Definition erarbeitet und Methoden dazu sortiert. 

**Wie trifft eine KI selbständig Entscheidungen?**

Eine häufige Aufgabe von KI ist es, Dinge zu klassifizieren: Ist ein Werkstück kaputt, ja oder nein? Ist die E-Mail Spam, ja oder nein? Versucht jemand beim Online-Shopping zu betrügen, ja oder nein? Um zu erklären, wie eine KI Dinge klassifiziert, habe ich das Beispiel „Monkey Cards“ von <a href="https://www.aiunplugged.org/" target="_blank" rel="noopener noreferrer">aiunplugged.org</a> eingesetzt, die Beschreibung und Affendarstellungen findet ihr <a href="https://www.aiunplugged.org/german.pdf" target="_blank" rel="noopener noreferrer">hier</a>. Es handelt sich dabei um vereinfachte Comic-Abbildungen von verschiedenen Affengesichtern. Ein Teil davon waren freundliche, nicht beißende Affen. Der andere Teil gehörte zu beißenden Affen. 

Die dargestellten Affen wurden unterteilt in Trainings- und Testdaten. Gemeinsam mit der Klasse wurde überlegt, welche Merkmale innerhalb der Trainingsdaten zur Klassifizierung „beißender Affe“ und „nicht beißender Affe“ verwendet werden können. Das wurde in einen Entscheidungsbaum überführt. Anhand der Testdaten wurde gezeigt, dass unser Modell funktioniert und in der Mehrheit richtige Entscheidungen getroffen hatte, aber auch nicht perfekt ist.

**Was sind die Grenzen von KI?**

Um uns den Grenzen der KI anzunähern, habe ich dann ein Bild eines Affen gezeigt, dessen Merkmale deutlich von den Merkmalen der Trainingsdaten abgewichen ist. Es wurde schnell klar, dass eine KI bei unbekannten Merkmalen anfängt zu raten, um eine Entscheidung zu treffen. 

![IMG_7324.jpg](https://eu-central-1.graphassets.com/AiE4QoWSSiIQO3k152ugkz/2H3s9BKbSaGVhrvQ30mt)

Abschließend wurden Anwendungsfälle aus meiner beruflichen Praxis vorgestellt und in einem Gespräch über Begegnungen der Schülerinnen und Schüler mit KI in ihrem Alltag gesprochen. Mir war dabei wichtig, nicht nur theoretisches Wissen zu vermitteln, sondern auch die praktische Anwendbarkeit von KI-Kenntnissen. Die Schülerinnen und Schüler wurden von mir ermutigt, selber kreativ zu werden und innovative Lösungen für reale Probleme mithilfe von KI zu entwickeln. Sie hatten auch direkt die Möglichkeit dazu: Im Anschluss haben die Schülerinnen und Schüler mit der Bearbeitung ihrer praktischen Lernaufgabe begonnen, ein Lager-Assistenzsystems im Rahmen der Konzeption smarter Logistik-Prozesse zu programmieren. Ich bin gespannt auf die Ergebnisse, die hier entstehen werden!


Eine Einführung in das Thema künstliche Intelligenz für Schülerinnen und Schüler 

People Lead und Location Management Bielefeld

People Lead and Location Management Bielefeld

IT Consultant

Profilbild von Dominik Fladung im Hemd und mit Brille

Wir Softwareentwickler leben in einem ständigen Dilemma. Jede Funktionalität der Software sollte durch *Unit-Tests* und *Integrationstest* abgesichert werden. Es sollten dabei so viel Tests wie nötig, aber nur so wenige wie möglich geschrieben werden. 

Schreiben wir zu wenige Tests, dann sind nicht alle Funktionalitäten unserer Software ausreichend abgesichert. Zu viele Tests bedeuten teure Entwicklungszeit, die wir in unnötige Tests investieren.
Da sich die Software im Laufe der Zeit stetig verändert, müssen wir die Tests auch immer wieder anpassen. Mit der puren Anzahl der Tests steigt natürlich auch der Aufwand für die Pflege unserer Testbasis.

Ein recht aufwendiger Teil der Tests ist die Bereitstellung der Testdaten. Daher werden ziemlich schnell standarisierte Testdaten bzw. *Test Fixtures* in den Projekten genutzt. Ein Vorteil dieser *Test Fixtures* ist der reduzierte Aufwand bei den Anpassungen. Statt hunderte von Tests zu ändern, müssen nur einige wenige Bereitstellungsmethoden aktualisiert werden.

Für diese Bereitstellungsmethoden werden in den eigenen *JUnit 5*-Tests diverse Ansätze herangezogen, der *Extension-Mechanismus* des Frameworks aber häufig außer Acht gelassen. Wie dieser genutzt werden kann, werde ich im Folgenden an einem einfachen Test vorstellen.  

## Der JUnit 5 Extension-Mechanismus

Der _Extension-Mechanismus_ modifiziert das Verhalten von Testklassen oder -methoden. Vor _Junit 5_ verwendete _JUnit_ nur die Erweiterungspunkte `TestRunner` und `Rule`. _JUnit 5_ ersetzt diese durch eine vollständige _Extension-API_. Die API gestattet es an fünf Extension-Points in den Lifecycle eines Tests  einzugreifen. In diesem Beitrag nutzen wir den  Extension-Point _Parameter Resolution_, aber dazu kommen wir später.

## Der Bibliotheksbenutzer, seine Ausleihe und die Gebühren aka die Domäne

Ein Problem und seine Lösung erklärt man am einfachsten an einem prägnanten Beispiel. Dieses Beispiel bedient sich an meinen IT-Erfahrungen aus der Studentenzeit. Ein Bibliotheksnutzer hat diverse Ausleihen von Büchern und ggf. stehen Gebühren für die Nutzung oder überfällige Medien an.

## Ein erster Test

In unserem Beispiel werden die aktuellen Gebühren für einen Nutzeraccount berechnet. Dazu wird ein Account für einen Bibliotheksnutzer erstellt und zwei Ausleihen hinzugefügt.
Da eine der  beiden Ausleihen überfällig ist, steht eine Mahngebühr von 3 Euro an.

```java
class LibraryTest {
  @Test
  void currentFees() {
    Patron patron = Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    Booking booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    Booking booking14 = Boocking.media(book14).till(LocalDate.now().plusDays(2)).build()

    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Für den ersten Test eine Menge Code für die Erstellung der Testdaten. Alle weiteren Tests mit ähnlichen Voraussetzungen benötigen ähnliche Codefragmente. Daher sollten wir versuchen diese Fragmente bestmöglich wiederzuverwenden.

## Weniger Boilerplate-Code

Für weitere Tests in der Klasse `LibraryTest` zentralisieren wir das Erstellen der Testdaten.
Die bekannteste Möglichkeit dafür ist eine mit `@BeforeEach` annotierte Methode.

```java
class LibraryTest {
  private Patron patron;
  private Booking booking9;
  private Booking booking14;

  @BeforeEach
  void setUp() {
    Patron patron = Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
    Book book9 = Book.title("Gevatter Tod").author("Terry Prattchet").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    booking14 = Booking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFees() {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Nun können sich alle Testmethoden die *Text Fixture* teilen. Da die `setUp`-Methode vor jedem Test aufgerufen wird, werden diese Daten leider auch für Tests erstellt, die sie gar nicht benötigen.

## Parameter Resolver in JUnit 5

*JUnit 5* erlaubt es, Parameter an Test und Lifecycle-Methoden zu übergeben. Dafür können eigene `ParameterResolver` implementiert werden.

```java
public class PatronParameterResolver implements ParameterResolver {

  @Override
  public boolean supportsParameter(ParameterContext parameter, ExtensionContext extension) {
      return parameter.getParameter().getType() == Patron.class;
  }

  @Override
  public Patron resolveParameter(ParameterContext parameter, ExtensionContext extension) {
    return Patron.id("id-001").name("Jens Kaiser").fees(LibraryFees.ADULT).build();
  }
}
```

Der `PatronParameterResolver` ersetzt alle Methodenparameter vom Typ `Patron` mit der Instanz, die von der Methode `resolveParameter` erzeugt wird. Wir dürfen nicht die `@ExtendWith` Annotation vergessen, sonst weiß _JUnit 5_ nicht, woher der `Patron`kommen soll.

Die Test-Klasse verkürzt sich nun um den vom `PatronParameterResolver` generierten Kunden.

```java
@ExtendWith(PatronParameterResolver.class)
class LibraryTest {
  private  Booking booking9;
  private  Booking booking14;

  @BeforeEach
  void setUp() {
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    booking14 = Booking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFees(Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Der Bibliotheksnutzer wird nun nur noch für die Testmethoden erzeugt, die diesen auch tatsächlich benötigen. Nur schade, dass es immer derselbe Nutzer ist. Kann man das nicht ändern?

## Variationen mit Annotationen

Eine Annotation am Parameter kann durch den Parameter Resolver ausgewertet werden und zur Modifizierung der Werte genutzt werden. Mit der Annotation `@Fixture` sind dann die folgenden Tests möglich.

```java
@ExtendWith(PatronParameterResolver.class)
class LibraryTest {
  private Booking booking9;
  private Booking booking14;

  @BeforeEach
  void setUp() {
    Book book9 = Book.title("Gevatter Tod").author("Terry Pratchett").build();
    Book book14 = Book.title("Lachs im Zweifel").author("Douglas Adams").build();
    booking9 = Booking.media(book9).till(LocalDate.now().minusDays(2)).build(),
    booking14 = Booking.media(book14).till(LocalDate.now().plusDays(2)).build()
  }

  @Test
  void currentFeesAdult(@Fixture("Jens") Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();

    assertEquals(3, account.getCurrentFees());
  }

  @Test
  void currentFeesChild(@Fixture("Christopher") Patron patron) {
    Account account = Account.by(patron).with(List.of(booking9, boocking14)).build();
    
    assertEquals(2, account.getCurrentFees());
  }
}
```

Der `PatronParameterResolver` entscheidet mit Hilfe der `@Fixture` Angabe, welcher Bibliotheksnutzer erstellt werden soll. Der zweite Bibliotheksnutzer bekommt geringere Mahngebühren, weil er noch ein Kind ist. 

Wir verwenden an dieser Stelle _Personas_, um unseren Tests, im wahrsten Sinne des Wortes, ein Gesicht zu geben. Die Persona _Jens Kaiser_ ist ein älterer Herr, der gelegentlich die Bibliothek besucht und _Christopher Robin_ ist ein kleiner Junge mit einem Teddybär.

## Das geht auch generisch

Häufig hat man es nicht nur mit einer Domänenklasse zu tun, sondern mit sehr vielen. Daher kann ein Großteil der Implementierung in einer generische Basisklasse verschoben werden.

```java
public class PatronFixtureParameterResolver 
      extends AbstractFixtureParameterResolver<Customer, Long> { 
  public PatronFixtureParameterResolver() {
    super(Patron.class, x -> (long) x);
  }

  @Override
  protected Patron createInstance(Long identifier, String persona) {
    String id = "id-%03d".formatted(identifier);
    return switch (persona) {
       case "Christopher" -> Patron.id(id).name("Christopher Robin").fees(CHILD).build();
       case "Jens", "default" -> Patron.id(id).name("Jens Kaiser").fees(ADULT).build();
       default -> throw new ParameterResolutionException("unknown patron: " + persona);   
     }
  }
}
```

Der `PatronFixtureParameterResolver` erbt von dem `AbstractFixtureParameterResolver`.
Dieser erzeugt nicht nur eine Instanz der gewünschten Klasse, sondern beherrscht auch Collections und Arrays dieser Klasse und wertet die `@Fixture` Annotation aus. Der `PatronFixtureParameterResolver` kümmert sich nur noch um die Erzeugung der Varianten. 

```java
public abstract class AbstractFixtureParameterResolver<T, I> implements ParameterResolver {
    private final Class<T> type;
    private final Function<Integer, I> identifierMapper;

    protected AbstractFixtureParameterResolver(Class<T> type, Function<Integer, I> mapper) {
        this.type = type;
        this.identifierMapper= mapper;
    }

    private boolean isCollection(Parameter parameter) {
        ParameterizedType type = (ParameterizedType) parameter.getParameterizedType();
        return type.getActualTypeArguments()[0] == type;
    }

    private boolean isArray(Class<?> parameterType) {
        return parameterType.isArray() && parameterType.getComponentType() == type;
    }

    @Override
    public boolean supportsParameter(ParameterContext context, ExtensionContext extension) {
        Parameter parameter = context.getParameter();
        Class<?> parameterType = parameter.getType();
        return parameterType == type || isArray(parameterType) || isCollection(parameter);
    }

    protected abstract T createInstance(I identifier, String variation);

    @Override
    @SuppressWarnings("unchecked")
    public Object resolveParameter(ParameterContext context, ExtensionContext extension) {
        Optional<Fixture> fixture = context.findAnnotation(Fixture.class);
        List<String> variations = fixture.map(Fixture::value).filter(l -> l.length > 0)
            .map(Arrays::asList).orElseGet(() -> List.of("default"));
        Class<?> parameterType = context.getParameter().getType();
        if (parameterType == type) {
            return createInstance(identifierSupplier.apply(0), variations.getFirst());
        }
        int size = fixture.map(Fixture::size).orElse(3);
        int offset = fixture.map(Fixture::offset).orElse(10);
        if (parameterType.isArray()) {
            List<T> list = createStream(offset, size, variations).toList();
            return list.toArray((T[]) Array.newInstance(type, list.size()));
        }
        if (parameterType == List.class) {
            return createStream(offset, size, variations).toList();
        }
        if (parameterType == Set.class) {
            return createStream(offset, size, variations).collect(Collectors.toSet());
        }
        throw new ParameterResolutionException("something went wrong: " + parameterType);
    }

    private Stream<T> createStream(int offset, int size, List<String> variations) {
        return IntStream.range(offset, offset + size)
            .mapToObj(x -> createInstance(identifierMapper.apply(x), 
                variations.get(x % variations.size())));
    }
}
```

## Mehrere Parameter-Resolver

Es geht natürlich auch mit mehreren `ParameterResolvern`. Neben dem `PatronFixtureParameterResolver` wird im folgenden Test auch ein `BookingFixtureParameterResolver` verwendet. Dieser erzeugt die Ausleihen für den Benutzeraccount.

```java 
@ExtendWith(PatronFixtureParameterResolver.class)
@ExtendWith(BookingFixtureParameterResolver.class)
class LibraryTest {
  @Test
  void currentFees(@Fixture("Jens) Patron patron, 
      @Fixture(variations={"Pratchett-2", "Adams+2"}, size=2) List<Booking> bookings) {
    Account account = Account.by(patron).with(bookings)).build();

    assertEquals(3, account.getCurrentFees());
  }
}
```

Der `BookingFixtureParameterResolver` generiert diverse Varianten von `Booking`-Instanzen. In der Testklasse werden keine *Test Fixture* mehr erzeugt. Alle *Test Fixtures* kommen nun aus Parameter Resolvern.

## Fazit

Mit dem _Parameter Resolver_ Extension Point bietet _JUnit 5_ einen mächtigen Mechanismus, um Test-Methoden mit _Test Fixtures_ zu versehen. Wir konnten sehen, dass eigene Parameter-Resolver ohne besonderen Aufwand erstellt und eingebunden werden können.  

Die Testdatenerzeugung mit Parameter-Resolvern bringt einige Vorteile. Der Mechanismus ist integraler Bestandteil des _JUnit 5_ Frameworks. Er ist etabliert, dokumentiert und bietet eine uniforme Lösung für die eigene Datenbereitstellung. Die Testdaten werden nur punktuell erzeugt und verwendet. Nur dort, wo sie als Parameter einer Testmethode angegeben sind, werden sie auch tatsächlich instanziiert. Außerdem können Variationen in den Testdaten über Annotationen direkt an den Parametern der Testmethoden konfiguriert werden.

Für alle, die neugierig geworden sind: einfach mal testen!

Test Fixtures mit JUnit 5

Senior IT Consultant

Werkstudent

IT-Consultant

Bielefeld | Team

Vielen Dank für deine Anfrage. Ich melde mich bei dir.

Vielen Dank für deine Anmeldung. Eine E-Mail zur Bestätigung ist zu dir unterwegs.

Diese Seite ist eine Vorschau. \nKlicken Sie hier\n, um den Vorschaumodus zu verlassen.

Zu deiner Suche haben wir leider keine passenden Blogartikel gefunden. 

Du hast noch Fragen zu diesem Thema? Dann sprich mich einfach an.

Du hast Fragen oder möchtest dich mit mir austauschen? Gern - trag einfach deine Kontaktdaten ein.

Die \nDatenschutzerklärung\n der codecentric AG habe ich zur Kenntnis genommen und bestätige das mit der Absendung des Formulars.*

Entdecke spannende weiterführende Themen und lass dich von der codecentric Welt inspirieren.

Ich möchte eure Inhalte abonnieren. Diese Einwilligung kann ich jederzeit widerrufen bzw. den Blog Newsletter abbestellen. Die Datenschutzerklärung habe ich gelesen. Ich bin damit einverstanden, dass die codecentric AG, Hochstr. 11, 42697 Solingen, mich über eigene Dienstleistungen, branchenrelevante Events, Webinare und Publikationen der codecentric AG über die von mir angegebene E-Mail-Adresse informiert. Meine Einwilligung ist freiwillig. Ich kann meine Einwilligung jederzeit mit Wirkung für die Zukunft widerrufen (z.B. über den hierfür vorgesehenen Abmeldelink in unserem Newsletter, per E-Mail an datenschutz@codecentric.de oder per Post an die oben genannte Adresse der codecentric AG) erklären. Weitere Hinweise zur Verarbeitung meiner personenbezogenen Daten und zu meinen Rechten als betroffene Person finde ich hier: \nhttps://www.codecentric.de/datenschutzerklaerung\n

Bitte wähle deine/n gewünschte/n Standort/e aus.

Wir möchten dich als Mensch kennenlernen. Erzähle uns, wer du bist, worauf du Wert legst, wie du gerne arbeitest und was du von uns als Arbeitgeber erwartest.

Bitte füge deine Bewerbungsunterlagen ​(mind. Lebenslauf, gerne auch mehr)​​ ​als eine ​PDF-​Datei ​hinzu.

Es gilt die Datenschutzerklärung der codecentric AG, abrufbar unter \nDatenschutzbestimmungen\n. Mit dem Absenden des Formulars bestätige ich, dass ich diese zur Kenntnis genommen habe.

Job application form field placeholder 10

Keine passende Rolle gefunden? Bewirb dich bitte trotzdem initiativ! Jenseits von starren Schubladen zählen für uns vielmehr Motivation, Kompetenz und der Cultural Fit.

Job application form field placeholder 11

Dies ist ein Pflichtfeld, bitte fülle es aus.

Willkommen im Team Bielefeld

Jetzt für unseren Newsletter anmelden