---
# System prepended metadata

title: JUnit

---

> [name=Martin. S]
> [time=Wed, Apr 13, 2023]
> [name=Lucas. C]
> [time=Wed, Apr 13, 2023]
> [name=Lukas. B]
> [time=Wed, Apr 13, 2023]
> [name=Linus. S]
> [time=Wed, Apr 13, 2023]


# JUnit
## 1. Grundlagen von JUnit:
JUnit ist ein Framework für das Testen von Java-Anwendungen, das Testannotationen wie "@Test" und einen Test Runner verwendet.


## 2. Elemente einer JUnit Testklasse und typischer Testaufbau:

Eine JUnit Testklasse ist eine normale Java-Klasse, die spezielle Elemente enthält, um Tests zu definieren.


-   **Testklassenname**: Der Name der Testklasse sollte mit dem Namen der zu testenden Klasse übereinstimmen und das Wort "Test" als Suffix enthalten. Zum Beispiel: "MyClassTest" für die Testklasse, die die Klasse "MyClass" testet.
    
-   **Testmethoden**: Testmethoden sind normale Java-Methoden, die mit der Annotation "@Test" gekennzeichnet sind und dazu dienen, bestimmte Funktionalitäten oder Verhaltensweisen zu testen. Eine Testmethode sollte unabhängig von anderen Testmethoden und in sich abgeschlossen sein.
    
-   **Asserts**: Asserts sind Aussagen, die in den Testmethoden verwendet werden, um zu überprüfen, ob bestimmte Bedingungen erfüllt sind. Zum Beispiel können Entwickler mit "assertEquals" überprüfen, ob zwei Werte gleich sind, oder mit "assertTrue" überprüfen, ob eine bestimmte Bedingung wahr ist.
    
-   **Test Runner**: Der Test Runner ist dafür verantwortlich, die Testklasse auszuführen und die Ergebnisse zurückzugeben. JUnit bietet verschiedene Test Runner, wie z.B. den "JUnit4" oder "JUnit5" Test Runner, die je nach Version des JUnit-Frameworks verwendet werden.


## 3.  Fixture-Methoden (@BeforeAll, @BeforeEach, @AfterAll, @AfterEach):

Sie dienen dazu, die Testumgebung vorzubereiten oder zu bereinigen und ermöglichen das Teilen von Ressourcen zwischen Tests.

### Wozu sind diese gut?

-   **@BeforeAll**: Diese Methode wird einmalig vor der Ausführung aller Tests in der Testklasse aufgerufen und eignet sich zum Beispiel für die Initialisierung von globalen Ressourcen, die von allen Tests benötigt werden.
    
-   **@BeforeEach**: Diese Methode wird vor der Ausführung jeder Testmethode aufgerufen und eignet sich zum Beispiel für die Initialisierung von Testdaten oder die Einrichtung von Testumgebungen, die für jeden Test individuell sein sollen.
    
-   **@AfterAll**: Diese Methode wird einmalig nach der Ausführung aller Tests in der Testklasse aufgerufen und eignet sich zum Beispiel für die Freigabe von globalen Ressourcen oder die Durchführung von Abschlussarbeiten.
    
-   **@AfterEach**: Diese Methode wird nach der Ausführung jeder Testmethode aufgerufen und eignet sich zum Beispiel für die Bereinigung von Testdaten oder die Wiederherstellung von Testumgebungen nach jedem Test.

### Wo würden wir das einsetzen
Fixture-Methoden könnten verwendet werden um beispielsweise Datenbankverbindungen zu initialisieren und freizugeben, Testdaten einzurichen und bereinigen. 

## 5. Einschränkungen im Zusammenhang mit Interfaces und abstrakten Klassen

1.  **Interfaces**: JUnit kann keine Tests direkt auf Interfaces ausführen, da Interfaces keine Implementierung von Testmethoden enthalten können. Stattdessen müssen Testklassen erstellt werden, die von den Interfaces erben und die Testmethoden implementieren.
    
2.  **Abstrakte Klassen**: JUnit kann keine abstrakten Klassen direkt als Testklassen verwenden, da abstrakte Klassen nicht instanziiert werden können. Stattdessen müssen konkrete Unterklassen von abstrakten Klassen erstellt werden, die die abstrakten Testmethoden implementieren.


# Teil 2 Praxis

## Aufgabe 1



## Aufgabe 2

### Setup für die Tests

```java
    @Autowired private LanguageController languageController;
    @MockBean private LanguageRepository languageRepository;
    @Autowired private MockMvc mockMvc;

    @BeforeEach
    public void setUp() {
        Language german = new Language();
        german.setId(1);
        german.setName("German");
        german.setFlag("de");
        when(languageRepository.findById(1)).thenReturn(Optional.of(german));
        Language english = new Language();
        english.setId(2);
        english.setName("English");
        when(languageRepository.findById(2)).thenReturn(Optional.of(english));
    }
```

### Test #1

```java
    /**
     * Get all language should contain name "German"
     */
    @Test
    public void CheckGetAlllanguageShouldHaveGerman() {
        Language language = languageController.getAllLanguageById(1).getBody();
        assertEquals("German", language.getName());
    }

}
```

### Test #2

```java
    /**
     * Get all language should contain "de" Flags
     */
    @Test
    public void CheckGetAlllanguageShouldhaveFlagDE() {
        Language language = languageController.getAllLanguageById(1).getBody();
        assertEquals("de", language.getFlag());
    }
```

### Test #3
```java
    /**
     * Method under test: {@link LanguageController#getAllLanguages()}
     */
    @Test
    public void CheckGetAllLanguages_isOk() throws Exception{
        mockMvc.perform(MockMvcRequestBuilders.get("/api/language/"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON));
    }
```
### Test #4
```java

    /**
     * Method under test: {@link LanguageController#getAllLanguageById(Integer)}
     */
    @Test
    public void CheckGetOneLanguageById_isOk() throws Exception{
        when(languageRepository.findById(anyInt())).thenReturn(Optional.of(new Language()));

        mockMvc.perform(MockMvcRequestBuilders.get("/api/language/{id}", "1"))
                .andDo(res -> System.out.println(res.getResponse().getContentAsString()))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(content().contentType("application/json"));
    }
```
### Test #5
```java
    /**
     * Test if the Language class is working correctly by createing the language French
     */
    @Test
    public void createLanguageFrench() {
        Language language = new Language();
        language.setId(3);
        language.setName("French");
        language.setFlag("fr");
        assertEquals(language.getId(), 3);
        assertEquals(language.getName(), "French");
        assertEquals(language.getFlag(), "fr");
    }
```
### Test #6
```java
    /**
     * Test if a Language can be deleted from setUp
     */
    @Test
    public void deleteLanguageGerman() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.delete("/api/v1/language/{id}", 1))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(content().string("Success: deleted"));
    }

```
### Test #7
```java
    @BeforeEach
    public void setUp() {
        LearnWord learnWord = new LearnWord();
        learnWord.setId(1);
        learnWord.setWord("Test");
        learnWord.setTranslation("Test");
        when(learnWordRepository.findById(anyInt())).thenReturn(Optional.of(learnWord));
    }

    /**
     * Get id 1 learnWord
     */
    @Test
    public void CheckIfWordWithIdOneEquialsTest() {
        LearnWord word = learnWordController.getWord(1).getBody();

            assertThat(word.getWord()).isEqualTo("Test");

    }
```
### Test #8
```java
    /**
     * Create learnWord with id 2
     */
    @Test
    public void CheckIfWordIsCreateableWithIdTwo() {
        LearnWord learnWord = new LearnWord();
        learnWord.setId(2);
        learnWord.setWord("Test2");
        learnWord.setTranslation("Test2");
        assertThat(learnWord.getId()).isEqualTo(2);
    }
```