Latest / Coding Buddies | Tech & Dev-Mindset / #155 Next Level Testing mit Testcontainers

Transcript

#155 Next Level Testing mit Testcontainers · Coding Buddies | Tech & Dev-Mindset

0:00
Stell dir mal folgendes vor. Du schreibst einen
0:01
integrationstest Test ist grün, das Ganze geht auf die Pipeline
0:05
grün und trotzdem funktioniert deine Software am Ende nicht
0:09
mehr, dein Code ist nicht kaputt, deine Logik ist es auch
0:11
nicht, sondern deine Datenbank, warum genau, darüber sprechen
0:16
wir in der heutigen Folge und warum es eine Lösung gibt, die
0:19
für viele Teams ein Game Changer war.
0:21
Coding Buddies Dein Podcast rund um Softwareentwicklung und
0:24
aktueller Tech News herzlich Willkommen.
0:39
Halli Hallo und herzlich Willkommen zur neuen Folge von
0:42
Coding Buddies Podcast, Deinem Podcast für Themen rund um die
0:47
Softwareentwicklung. Und zwar mit den Coding Buddies
0:49
und zwar mit mir, dem Fabi und dem Tino.
0:51
Der sitzt mir gegenüber, er hat, ich sag jetzt einfach mal Bock,
0:55
er sieht aus als hätte er Bock. Tino, Wie geht es dir?
0:57
Grüß dich, Fabi, was geht ab, was geht ab, was geht down?
1:03
Ja, haben wir ja auf Twitch gelernt.
1:05
Jetzt ne. Ja, richtig, richtig.
1:08
Ja ja, was geht, was geht. Ich hab Bock, hast du gut
1:10
erkannt, ich hab ich hab richtig.
1:11
Bock ist schön, klingst sehr entspannt.
1:15
Das ist. Doch klar, Mensch, aber lass
1:17
dich nicht täuschen. Ja, ich bin Feuer und Flamme für
1:20
das heutige Thema eher. Entspannt sein, das ist in
1:23
Ordnung. Also ich war kurz fast nicht
1:25
entspannt, weil kennst du das? Wenn du also es gibt ne Sache,
1:29
die find ich richtig richtig schlimm ne.
1:31
Und zwar wenn du so kennst, du so.
1:32
Du hast Krümel, die liegen irgendwo rum, ne kennt man und
1:37
jetzt fängst du an diese Krümel zu nehmen und willst die so
1:41
runter wischen in deine Hand rein.
1:43
Vom Tisch oder so. Ja, vom Tisch oder so.
1:45
Aber am besten ist die Kante noch so.
1:47
Du kommst nicht ganz mit der Hand runter, sondern du kannst
1:49
nur so an diese Kante ran. Du hast nicht so n richtigen
1:52
Tisch weißt du, sondern nur so wenig Platz, so dass du das
1:55
nicht runter schieben kannst unter die Kante, dann wischt du
1:57
das so runter. Und dann wird keine.
1:59
Saubere Nummer oder nee? Und dann fallen, ich weiß nicht,
2:02
wie es bei dir ist, aber manchmal fallen so Krümel durch
2:05
die Löcher zwischen den Fingern. Ich weiß gar nicht, was ich dazu
2:11
sagen soll. Also das hören wir weiter.
2:14
Das ist einfach super schlimm. Also du willst ja einfach nur
2:17
das so in die in die Handfläche machen, aber dadurch, dass du ja
2:21
nicht die Handfläche so richtig ranbringen kannst fallen fällt
2:24
es auf die Handfläche und auf auf die Finger und bei den
2:26
Fingern dann zwischen diese. Fingerlöcher nenn ich es jetzt
2:29
mal. Fingerlöcher warte, ich guck
2:31
gerade in meine Hand, OK, aber kannst du die Hand nicht, sag
2:35
ich mal für dieses Szenario besser formen in Position
2:38
bringen, dass da nicht so große Fingerlöcher sind.
2:41
Also ich hab es probiert, ich hab ne Menge probiert, das
2:44
passiert trotzdem immer wieder und ich bin übelst angenervt
2:46
davon. Ich hab das Gefühl du kennst das
2:49
nicht so. Aber nee, ich finde das nicht so
2:52
krass tatsächlich. Ich versuch mich aber gerade
2:54
natürlich wie immer ja. Als guter, als guter war die
2:57
Versuch ich mich natürlich in deine Lage zu versetzen.
3:00
Ich frag mich grad, ob ich das auch so anpissen würde, aber ich
3:03
stell es mir mal vor und wie wie hast du es gelöst?
3:06
Ich hab es, ich kann es nicht lösen.
3:07
Das fällt auf den Boden und das nervt dann vorsichtiger.
3:12
Ach so OK, kommt drauf an wenn ich n guten.
3:14
Tag, hab einmal runtergefallen. Bleibt es da?
3:18
Mich würd ja mal interessieren, ob das jemand auch so kennt.
3:21
Dann schreibt uns bestimmt. Also das ist halt eine
3:25
Nachricht. Absolut.
3:26
Anstrengend, genauso anstrengend?
3:28
Ja, ist es zum Beispiel auch, wenn man Tests hat, die Grün
3:34
sind, aber dann am Ende deiner Anwendung trotzdem nicht läuft
3:37
ja auch super nervig und genau darum geht es heute in dieser
3:41
Folge. Oh, starke Überleitung, genau,
3:48
ja, du lernst dazu auf jeden Fall.
3:52
Genau. Was ist unser heutiges Thema?
3:54
Wir wollen genau darüber sprechen, was du angedeutet
3:58
hast, weil es einfach super viele Entwickler trifft und
4:00
betrifft und deswegen hau ich einfach mal das erste Stichwort
4:04
so in den Ringen, in unseren Podcastring und zwar Integration
4:07
Tests, das wird heut viel um Integration Tests gehen
4:12
einerseits als Problem und gleichzeitig wie man mit
4:17
gewissen Tools. Die Lösung für diese Integration
4:20
Tests schaffen kann, um einfach das ganze, sag ich mal,
4:24
angenehmer zu gestalten, weil Fakt ist Integration Test
4:28
spielen eine sehr sehr wichtige Rolle, das würd ich gerne mit
4:30
dir auch noch mal n bisschen motivieren, weil die Lösung ist
4:33
jetzt nicht weil dann wär die Folge ziemlich kurz einfach
4:35
keine schreiben nein das ist nicht die Lösung aber man merkt
4:40
halt oft, dass Projekte zum Beispiel viele gute Unit Tests
4:44
haben, ne oder auch zeigen so ja guck mal hier Code coverage ja.
4:49
95% an der 100 arbeiten wir, aber es sind schon 95 so ist n
4:54
bisschen überspitzt gesagt. Ja, Code coverage kann man
4:57
halten, davon halten was man will, uns ist es zum Beispiel
4:59
nicht ganz so wichtig, dann lieber n paar Integration Tests
5:03
dazu ja, aber was ist jetzt so das Problem dabei bei
5:07
Integration, Test und Kernproblem worauf man immer
5:09
wieder stößt. Bei Integration Test na ja, das
5:13
Problem ist halt genau diese Integration.
5:15
Ne, also du hast ja Unit Test testet halt im Endeffekt
5:18
eigentlich reines reine Logik, also wirklich so ne einfache
5:21
Funktion. Du hast n Input, du hast n
5:23
Output da drin passiert irgendwas, es ist ne Berechnung,
5:25
also kann man sich vorstellen wenn du einfach sagst du
5:29
möchtest halt irgendwie. Aus einem Array, zum Beispiel
5:33
von Zahlen. Möchtest du irgendeine bestimmte
5:35
Berechnung machen und erwartest dann halt zum Beispiel einfach
5:38
irgendeinen Ausgabewert ne oder du willst irgendwie nach
5:41
bestimmt irgendwie nach einer bestimmten Art und Weise etwas
5:44
sortieren und erwartest dann eine Sortierung so wie du sie
5:48
dir vorstellst, einer Liste oder so.
5:49
Als kleines Beispiel, dass man sich das vorstellen kann und das
5:53
sind sehr, sehr einfache Tests in Anführungsstrichen, einfach
5:56
weil du hast keine Abhängigkeiten, du hast diese.
5:59
Klasse zum Beispiel, oder diese Funktion.
6:01
Und diese Funktion hängt von nichts ab.
6:04
Du kannst einfach mit diesem Code, der läuft arbeiten und das
6:08
ist bei Integration Tests nicht unbedingt der Fall oder
6:10
eigentlich genau deshalb nicht der Fall, weil du zum Beispiel
6:13
Abhängigkeiten hast. Du hast.
6:15
Deine Logik und diese Logik nutzt einen Service zum Beispiel
6:19
n anderen Service und dieser Service zum Beispiel nutzt
6:21
wiederum irgendwie hat n ne Connection zur Datenbank oder du
6:25
testest n Service der direkt ne Connection zur Datenbank hat,
6:28
also rein theoretisch, also in in echt ne, aber wenn du jetzt
6:33
gerade in diesem Unit testbereich bist zum Beispiel
6:36
oder halt vielleicht auch sagst, OK, ich möchte zwar irgendwie,
6:40
also ich hab eigentlich ne Integration irgendwohin.
6:44
Aber diese Integration möchte ich wegkapseln, damit ich
6:46
eigentlich nur diesen Unit, also diesen Unit testen kann.
6:49
Ja, das heißt du Kapst hart diese Integration, also du
6:52
kapselst quasi Abhängigkeiten aus, das ist es ja am Ende, wenn
6:56
du sagst, du möchtest wirklich nur diese, diesen diese Unit
6:59
testen. Das Problem an dieser Stelle ist
7:02
jetzt natürlich, wie du meintest, du hast natürlich
7:06
genau diesen diese Abhängigkeit nicht getestet, das heißt wenn
7:09
du sagst, du möchtest beispielsweise irgendwie was
7:11
testen, was mit der Datenbank funktioniert.
7:13
Kannst du natürlich sagen, du Mogst das oder Fakest das, das
7:17
heißt du gibst irgendwie nen festen Rückgabewert zurück oder
7:20
du sagst du bildest dir ne eigene kleine Logik was da
7:23
passiert, kann aber dazu führen, dass gerade diese Schnittstelle
7:28
dann am Ende nicht richtig funktioniert oder diese
7:30
Komponente die dahinter hängt nicht genauso funktioniert wie
7:33
sie funktionieren soll. Ne oder du sagst also ne, das
7:37
ist ja jetzt im Ende, du kannst es ja noch weiter treiben und
7:39
sagen. Gut, man muss es ja nicht
7:40
unbedingt mocken oder faken, aber du kannst ja auch ne andere
7:43
Komponente daran hängen, die zwar irgendwie das ist was du
7:48
willst, aber auch nicht hundertprozentig, was am Ende
7:50
bedeutet. Das was du lokal hast oder was
7:53
du in deiner Testumgebung hast, ist nicht gleich deiner prot
7:56
Umgebung ne. Genau das ist so im Prinzip das
8:00
Fazit. Wenn wir noch mal auf die Code
8:04
Coverage kommen bei Unit Test. Ja du kann ja 100% sein und jede
8:07
Codezeile wird angelaufen in den Tests, aber du testest wie du
8:12
meinst ja immer nur von deiner Seite aus und gibst ja statisch
8:16
zum Beispiel vor was nach draußen geht oder was du
8:19
empfängst. Ja also das kapselst du ab und
8:22
gibst es im Test vor, was ne gute Sache ist.
8:24
Keine Frage, Unit Test sind super wichtig.
8:27
Aber das Problem ist einfach. Wer gewährleistet dir jetzt das
8:30
in Port, also in der Produktivumgebung auch wirklich
8:34
die Daten gefordert sind vom Third Party zum Beispiel ne von
8:38
einem anderen Service oder du auch wirklich die Daten so
8:41
kriegst und kriegen kannst. Und das ist ja n riesen Punkt,
8:46
weil du stellst dir eine idealisierte Welt in deinen
8:50
Tests vor, wie du sie gerade annimmst.
8:52
Aber ob sie wirklich so ist und das so funktioniert kannst du
8:54
halt gar nicht wissen, ne? Und deswegen gibt es ja
8:58
Integration, Tests und da sagt man sich ja, aber ich kann ja
9:02
nicht immer die komplette Infrastruktur, wie du sie gerade
9:05
angesprochen hast, aufbauen. Ja, das ist ja super stressig,
9:09
gut, dann brauche ich jetzt den Service, ja und der braucht aber
9:11
das OK und dann willst du ja nicht.
9:15
Sagen immer in meinen Tests gehe ich gegen irgendwelche echten
9:18
Services oder nehmen wir mal Datenbanken, daran kann man das
9:22
auch ganz gut erklären, weil das ja auch Integration Test
9:25
bedeutet zu sagen, ich möchte jetzt aber wirklich mal Daten
9:28
aus meiner Datenbank ziehen, oder?
9:30
Reinschreiben. Ja, du möchtest ja das nicht mit
9:33
deiner Prot Datenbank machen. Du kannst ja nicht die Tests auf
9:36
deiner produktiven Datenbank laufen lassen.
9:38
Ja, also musst du ja wieder irgendwas schaffen, was
9:42
einerseits das Ziel von Integration Tests erfüllt und
9:46
andererseits aber wirklich noch ne Testumgebung ist.
9:49
Und das ist ne super schwierige Sache und da gab es so
9:52
verschiedene Lösungen in den letzten Jahren, die auch gut
9:54
waren, die sich immer mal gegenseitig n bisschen überholt
9:57
haben und verbessert haben. Aber beispielsweise ich glaub
10:01
das kennt viele, sind so in Memory Datenbank.
10:04
Ja dass du sagst ich habe ne Datenbank die ist so aufgebaut
10:07
wie meine echte Datenbank, die läuft aber komplett in meinem
10:11
Speicher im RAM. Das heißt, da kann eigentlich
10:13
nichts passieren. Ich fahr die hoch, die wird im
10:15
Speicher aufgebaut, ich kann dann Daten da reinschreiben und
10:18
wenn ich die Runterfahre und dann ist die aus dem Speicher
10:21
raus und fertig, ja ist halt flüchtig in dem Moment.
10:24
Ja, das heißt, die Daten sind natürlich auch immer wieder weg,
10:26
was ja aber für Tests voll OK ist sogar gewünscht, du möchtest
10:30
ja immer die gleiche Ausgangssituation haben, denn
10:33
deswegen ist es ja auch wichtig das Ganze reproduzierbar zu
10:37
machen. Wenn ich jetzt zum Beispiel
10:38
gegen die echte Datenbank gehe, ja und sage ich füge.
10:42
Diesen Eintrag hinzu und danach gibt es in dieser Tabelle einen
10:46
Eintrag. Sowas ist ja dann schon ziemlich
10:48
schwierig, wenn das die echte Datenbank ist und da die ganze
10:50
Zeit durch dein produktivsystem Daten rein und rausgehen ja,
10:54
also nur mal als Beispiel jetzt. Ich mein, rein theoretisch hast
10:56
du ja einmal, dass du sagst, du lässt den Test einmal laufen,
10:59
wenn du ihn noch mal laufen lässt.
11:00
Hast du diesen Eintrag ja schon drin.
11:01
Ne, das ist das eine und das andere ist, du hast ja
11:04
eventuell, also ganz sicher, wenn du das machst auf deiner
11:08
Produktivdatenbank. Super viele Testdaten, einfach
11:11
drin. Ja, also das findest du ja auch
11:13
nicht, also selbst wenn du irgendwie n System hast wo du
11:16
User irgendwie hast ist es ja dann am Ende zum Beispiel auch
11:19
gar nicht mehr kann das kann du kannst ja auch gar nicht mehr ne
11:22
Aussage treffen darüber wieviel User gibt es denn auf meinem
11:25
Service? Weil keine Ahnung 90% sind davon
11:28
Test User die einfach so entstanden.
11:31
Richtig richtig kommt ja nach. Genau deswegen fängst du ja an,
11:33
denn wieder Testumgebung zu schaffen, dann fängst du wieder
11:36
an, Fakes und Mogs zu schreiben, ne oder halt ne in Memory
11:39
Datenbank zu nehmen, das heißt du gehst zwar n Schritt weiter
11:42
und Gaukelst wieder irgendeine Integration vor, aber sie ist
11:46
auch nicht so richtig, also sie kommt sag ich mal deiner echten
11:51
Umgebung natürlich wesentlich näher als n reiner Unit Test.
11:56
Aber es ist immer noch nicht so deine echte Umgebung und
11:59
deswegen trifft trifft man quasi bei dieser Art und Weise ja zum
12:04
Beispiel mit in Memory Datenbank.
12:07
Da haben wir auch ja selbst unsere Erfahrung gesammelt, würd
12:09
ich gern mit dir nachher auch drüber sprechen wie warum wir
12:13
zum Beispiel gewisse Dinge umgestellt haben und das ist
12:16
nämlich ein Grund davon, du triffst halt zwangsläufig
12:18
irgendwann auf Bugs, weil du sagst ey es läuft in meiner in
12:21
Memory Datenbank alles cool. Beispielsweise auch so Datenbank
12:26
Migration Riesen Stichwort können wir auch später noch mal
12:29
genauer drauf eingehen, aber es ist halt nicht deine echte
12:33
Datenbank. Du hast zum Beispiel produktiv
12:35
postress laufen, ne ne postress SQL Datenbank und in Memory
12:41
sagst du ja es ist ne meinetwegen ne Age to in Memory
12:45
Datenbank postress angelehnt so ne aber es ist halt nicht das
12:49
gleiche ja das eine. Simuliert das sag ich mal und
12:54
das andere ist wirklich ne echte Datenbank.
12:56
Und ja, die sind nicht schlecht, für gewisse Sachen ist immer die
12:59
Frage wie umfangreich nutzt du das oder was machst du wirklich
13:02
damit? Ja wie komplex ist deine
13:04
Datenbank, ich will das ja nicht verteufeln, wir haben ja auch
13:07
öfter schon in Memory Datenbanken genutzt, aber wenn
13:10
es wirklich Richtung viele Migration geht, komplexere
13:15
Statements zum Beispiel, ja dann merkst du halt dann kommt n
13:18
Punkt dass gewisse Features. Die eine Datenbank unterstützt
13:23
und die andere nicht. Dass gewisse Migrationen auf der
13:25
einen Laufen und auf der anderen nicht und im Worst Case läuft es
13:28
in Memory alles rund. Du sagst ey meine Tests sind
13:31
grün, läuft doch alles schiebst das Ganze produktiv hoch und auf
13:35
einmal sagt Deine Datenbank so ist nicht mehr das war es ja
13:38
Migration fehlgeschlagen oder Daten irgendwie korrupt was auch
13:41
immer denn passieren kann. Ja und das ist halt n echt n
13:44
großes Problem ja und n großes Risiko und da hat man quasi.
13:50
Sich dann über die Jahre Gedanken gemacht, wie kann ich
13:52
das denn besser machen? Und jetzt denkt sich vielleicht
13:56
der ein oder andere Na hier ja gut Integration Test hin oder
13:59
her, so oft kommt das ja auch nicht vor, aber ganz klar muss
14:04
man hier auch sagen, dass moderne Software sehr sehr oft
14:08
viel Integration Code beinhaltet.
14:10
Ja und das ist jetzt nicht nur Datenbank, Datenbank ist somit
14:13
das Erste was beispielsweise bei Backends immer mit dranhängt
14:17
oder oft. Ja.
14:19
Aber du hast ja auch. Wie du meintest so Third Party
14:22
Services zum Beispiel sowas wie Search Engines wie elastic
14:28
Search oder so wo du sagst ja ich kann ja nicht immer gegen
14:31
nen Service gehen der mich echt Geld kostet, auch am Ende ja ist
14:35
ja auch n Punkt wenn da irgendein Abo ne Paywall
14:38
sozusagen dahinter ist, dass ich sage jede Anfrage kostet mich
14:41
Geld oder sagen wir mal heutzutage.
14:43
Mit mit irgendwelchen APIS von von LLMS oder sowas.
14:48
Ja ist ja auch n Punkt ne weil sich.
14:51
APIS auch schnell wechseln können.
14:52
Ne, da hatte ich jetzt zum Beispiel, also da hatten hatte
14:55
ich mal in einem alten Projekt haben wir auch so eigentlich
15:00
genau versucht dieses Thema so zu tackeln sag ich jetzt mal,
15:03
weil da ging es auch wirklich darum, dass wir halt ne relativ
15:07
komplexe Infrastruktur hatten, auch mit Services, von denen das
15:11
ganze abhing und so weiter. Und diese Services hatten aber
15:15
eben zum Beispiel keine. Du hattest keine Möglichkeit da
15:17
so ne Art Testinstanz zu nutzen, ne, manchmal hast du ja bei
15:21
Services, das ist ja ganz cool, wenn du wirklich sowas hast wie
15:24
ne QR Instanz, ne prot Instanz und wirklich ne ne dev Instanz
15:29
wo du wirklich gefühlt alles mitmachen kannst was du
15:31
eigentlich machen möchtest, so dass das ist.
15:32
So Play Ground, dann ne. Genau, dass es auch zur
15:34
Verfügung gestellt wird, also dass.
15:36
Ich zum Beispiel sage mal als Beispiel ne Tino, Ich hab hier
15:38
nen Service und du kannst diese Instanz nutzen, da kannst du
15:42
alles mitmachen wie du möchtest. So ne und die ist aber immer to
15:45
Date zu dem was eigentlich die eigentliche Anwendung macht.
15:48
Ne das ist natürlich auch wirklich wichtig an der Stelle,
15:50
weil wenn du zum Beispiel deine Dev Anwendung anders gestaltest,
15:53
also deutlich anders als die pod Anwendung und das nimmst du dann
15:55
zum Testen ist natürlich auch wieder schwierig weil dann
15:58
testest du gegen ne Instanz wie prot und wenn du dann aber am
16:01
Ende gegen Prot arbeitest sozusagen, dann ist es natürlich
16:03
schwierig. Was ich interessant fand, war,
16:06
dass wir dann genau an der Stelle uns auch überlegt haben,
16:09
was kann man denn jetzt machen, weil dann kommst du nämlich
16:11
genau in diesen Punkt. Du willst Integrations
16:12
Integration Tests schreiben ja und hast aber keine Instanz auf
16:24
der du das machen kannst. Also fragt man sich dann OK mog
16:28
ich das oder wie mach ich das? Und dann haben wir am Ende
16:30
gesagt OK wir nehmen Dockercontainer und bauen da so
16:32
n Kleines. Node backend rein in so
16:35
nodexpress haben wir genommen, war ging halt super schnell das
16:38
einfach zu machen und auf bestimmte Anfragen haben wir
16:40
halt valide Antworten zurückgegeben, was auf jeden
16:44
Fall ne gute Sache war und auf ich sag mal dem ganzen schon
16:47
relativ nah kam für du hast eine Umgebung die einigermaßen
16:52
ähnlich ist zu der mit der du arbeitest.
16:54
Zumindest für diese Calls die du testen willst die du nutzt, aber
16:59
weil du ja auch meintest so du hast zum Beispiel ne externe
17:01
API, das war ja genau das gleiche.
17:03
Und da hatten wir zum Beispiel auch das Problem, dass wir zwar
17:07
lokal gemerkt haben, ey, wir lassen unsere ganzen Tests
17:09
laufen, alles ist cool, aber auf einmal hat es auf der auf auf,
17:13
ich sag mal zumindest auf der dev Umgebung nicht mehr
17:15
funktioniert, weil da liefen dann zum Beispiel oder auf der
17:17
QR Umgebung, weil ich glaub ne QR Stage hatten sie oder so oder
17:20
irgendwo ne spätestens bei prot hat es halt geknallt, weil diese
17:26
diese die API von denen sozusagen angepasst wurde.
17:29
Das hast du natürlich nicht angepasst in deinem.
17:31
Moc oder in deinem ich sag mal Container moc.
17:33
Es war ja sozusagen irgendwo ne Art kleines kleiner
17:37
Dockercontainer für Integrationtest, der aber am
17:39
Ende doch nichts anderes als n moc war für diese API ne, aber
17:44
wie gesagt war ganz nett gedacht, aber am Ende hast du
17:47
immer noch dieses Problem, dass das halt nicht hundertprozentig
17:52
funktioniert hat, was natürlich aber auch allgemein n
17:56
schwieriges Thema ist. Ne, wenn du irgendwo n externen
17:58
Service nutzt, den du halt nicht.
18:01
Für Tests nutzen kannst in dem Fall, aber dir fehlt halt die
18:04
Umgebung, ne. Aber man muss natürlich sagen,
18:07
dadurch habt ihr ja die Integration Tests ja schon ein
18:13
Stück realistischer gemacht, ne, weil ja wirklich ne echte
18:16
Kommunikation dann stattfindet. Das heißt der Gedankengang
18:20
dahinter war ja absolut richtig, es war ja auf jeden Fall ne gute
18:23
Practice das so zu machen. Natürlich hast du recht, das
18:27
Ding ist halt. Es gibt ne Sache, die kannst du
18:29
halt schwer lösen, wenn der Service den du verwendest es
18:32
nicht bereitstellt Testumgebung zu haben, wirst du natürlich
18:37
niemals das so sauber sag ich mal faken können oder nachbauen
18:44
können, dass es zu 100% immer dem dem echten Service
18:49
entspricht. Also ihr seid ja sehr nah
18:51
rangekommen, indem ihr quasi. Die Antworten realistisch
18:55
übertragen habt, aber die waren natürlich am Ende gemockt.
18:57
Aber das meine ich. Es ist halt, es ist halt quasi
19:00
möglichst daran, wenn es nicht ganz dran geht, sozusagen ne,
19:05
dann kann man wenigstens versuchen so weit wie möglich
19:07
und. So genau.
19:07
Aber wenn die natürlich was umstellen.
19:09
Irgendwelche Versionen der APIS sich weiterentwickeln, ne, dass
19:14
du auf einmal andere keine Ahnung, Endpunkte fallen weg,
19:17
neue kommen dazu, sie ändern sich, ist ja gang und gäbe dass
19:20
sowas passiert, ne. Dann kann es natürlich sein,
19:24
dass dann das Ganze auch failed am Ende oder dir noch
19:28
vorgaukelt, dass es funktioniert, aber auf prod.
19:31
Dann halt nicht mehr. Aber deswegen finde ich auch das
19:34
Beispiel deswegen ganz kurz noch, weil du gesagt hast,
19:37
Datenbanken und lästig Search zum Beispiel, das sind ja zum
19:40
Beispiel Dinge, die kannst du ja wirklich 1 zu 1 sozusagen ich,
19:44
ich sag mal nachstellen und nicht mit einer Memory Datenbank
19:47
zum Beispiel ne. Und das ist ja cool, ne?
19:49
Also da deswegen nur noch mal ganz kurz, es geht nicht immer
19:52
hundertprozentig, aber wenn es geht, dann kann man es halt
19:55
machen und das ist halt dann das gute, genau weil sonst hast du
19:59
am Ende immer das Problem dieses typische Works on My Machine
20:02
greift hier halt auch ne, weil das was bei euch da auch noch
20:06
der Fall war ich mein Ich weiß nicht genau wie ihr es umgesetzt
20:09
habt, aber es ist zwar n Schritt weiter zu sagen ich fahr selbst
20:12
dockercontainer hoch wo das läuft gegen die lass ich denn
20:15
meine Tests laufen ist ne gute Sache aber bringt.
20:18
Bringt natürlich auch ne gewisse Konfiguration Infrastruktur mit
20:22
sich. Die Umgebung muss passen, bei
20:24
dem anderen läuft es bei dir selbst nicht.
20:26
Er sagt Works on my machine, not my Problem, so weißt du aber an
20:32
der Stelle und auch mit diesen Def Ops Gedanken der hier auch
20:35
wieder greift, wie schaffen wir es denn das Ganze automatisiert
20:41
und quasi. Auf jeder Plattform, bei jedem
20:46
so laufen lassen zu können, dass es immer gleich funktioniert,
20:48
dass es bei dir lokal funktioniert, bei deinem
20:51
Kollegen lokal funktioniert es auf der Pipeline funktioniert
20:54
und im besten Falle natürlich auch noch dem Produktiven
20:57
entspricht. Und da sind halt wie gesagt in
21:02
in Memory Datenbanken haben wir schon drüber gesprochen, sind
21:04
super bequem, sie sind vor allem schnell ne, weil das wird in
21:07
Speicher geladen aus dem Speicher gezogen fertig super
21:10
Sache und. Wir wollen ja auch immer so n
21:14
bisschen über unsere Projekte reden und zum Beispiel das
21:17
Backend, was wir für unsere Coding Buddies Services
21:21
schreiben. Hatte ja im Prinzip auch anfangs
21:25
in den Tests eine in Memory Datenbank, weil das Macht
21:28
einfach Sinn auch so zu starten. Ja das geht schnell, ist schnell
21:31
eingerichtet und es ist schnell, flexibel und pflegeleicht sag
21:36
ich mal ne das Bedarf kein großes Setup, das heißt?
21:40
Das knallst du in deine Testumgebung mit rein und wenn
21:43
du jetzt beispielsweise das Ausführst und das Repo
21:46
Auscheckst so gerade am Anfang, da musst du nicht viel machen.
21:49
Weißt du, das läuft so. Wenn ich jetzt aber den Weg gehe
21:52
und sage, na ja, aber warte mal, du brauchst hier den
21:55
Dockercontainer und dann den Dockercontainer und warte man
21:58
zieht dir mal das noch und weißt du ist jetzt überspitzt gesagt,
22:02
lässt sich auch automatisieren ist mir klar, aber es bringt
22:06
halt natürlich mehr Aufwand mit sich, ne und?
22:09
Genau da sind wir aber und deswegen auch das Thema heute
22:13
plus an die Anmerkung haben wir gar nicht gesagt, Wa wie es war
22:17
auch n Community Wunsch auf das auf die Lösung des Problems wo
22:20
wir gleich noch drauf eingehen und deswegen dachten wir uns ey
22:23
Mensch das sind unsere Erfahrungen die genau mit dieser
22:25
Lösung sehr gut matchen, deswegen haben wir uns natürlich
22:28
dem Thema angenommen jetzt was wollte ich sagen Ach so genau
22:33
aber wir sind natürlich dann trotzdem irgendwann in das
22:35
Problem gelaufen, dass die in Memory Datenbank zu sehr.
22:38
Abweichend war von unserer Produktivdatenbank spätestens
22:43
bei Datenbankmigration auch n sehr spannendes Thema.
22:48
Nutzen wir beispielsweise an der Stelle Flyway für liebe Zuhörer,
22:51
liebe Zuhörer, falls sich das Thema interessiert
22:53
Datenbankmigration, wo jetzt viele sagen.
22:57
Hau bitte ab mit dem Thema, denkt sich ja vielleicht der ein
23:01
oder andere ist n Cooles. Thema ist spannend, ist wichtig.
23:03
Wichtig ist es auf jeden Fall, dann schreib uns gerne, wenn wir
23:07
da mehr Content zu machen sollen oder meine eigene Folge zu
23:10
definitiv, ich find es aber auf jeden Fall ganz interessant um
23:14
kurz einzuhaken an der Stelle, weil genau die weil du
23:18
datenbankmigration ansprichst und ich finde datenbankmigration
23:21
ich finde du kannst alles eigentlich relativ entspannt
23:24
testen, ne und? Auch bei dem Beispiel, was ich
23:27
genannt hatte, zum Beispiel, da haben wir auch echt ne Menge
23:29
Tests gehabt. Wir hatten halt Unit Tests, Wir
23:31
hatten Integration, Tests, Wir sind noch weiter gegangen mit
23:33
System Tests und hatten halt zum Beispiel diese Dockercontainer
23:36
die wir da hatten, hatten wir auch für die System Tests
23:39
laufen, im Endeffekt war es dann auch so, dass immer wenn wir die
23:42
Tests gestartet haben einfach lokal ne kleiner Befehl, dass
23:45
die Tests starten, da wurden dann auch weil am Anfang war es
23:48
dann so irgendjemand kommt neu ins Team.
23:50
Lässt die Tests laufen und sagt ja, es geht nicht.
23:52
Hier failen Tests und ja OK hast du die Docker, also Docker
23:55
compost gemacht so ne bis man dann irgendwie sich denkt so OK
23:58
ist paar mal passiert, lass das mal noch in diesen Testbefehl
24:02
mit reinpacken das wenn du den Testbefehl ne so nach modern ne
24:05
NG test keine Ahnung frag mich nicht NPM test aber also egal
24:11
welche Testumgebung du gerade laufen lässt, aber das was du
24:13
wolltest einfach diesen testbefehl ne Test all mir egal.
24:19
Lässt du laufen, dann sind halt die Docker Container
24:22
hochgefahren und dann wurde alles getestet.
24:24
Dann sind einmal die Unit Tests durchgelaufen, die Integration
24:26
Tests, die E To e Tests und alles mögliche und das ist
24:30
soweit ja auch ganz gut und es hat auch sehr wurde auch sehr
24:33
viel abgetestet und die Test Abdeckung oder die ich sag mal
24:37
die Verlässlichkeit. Dass deine, Deine, dass deine
24:43
Software auch richtig funktioniert, die war echt hoch,
24:45
muss ich sagen, die hat mir sehr gut gefallen und es gab aber
24:48
wirklich einen Painpoint, der mir immer wieder Bauchschmerzen
24:52
gemacht hat und das war datenbankmigration muss ich ganz
24:54
ehrlich sagen, weil ich zum Beispiel auch schon geschafft
24:57
habe ne wie du meintest, selbst wenn du ne Datenbank hast, die
25:01
du irgendwie lokal nur mal so laufen lässt und aber zum
25:07
Beispiel dann. Diese ganze Migration, ne, also
25:11
von Flyway beispielsweise, oder es gibt ja auch Liqui Base oder
25:14
was auch immer man da nehmen möchte, aber wenn diese nicht
25:17
durchläuft in deinen Tests oder in deiner Umgebung, dann hab ich
25:21
es zum Beispiel auch schon mal geschafft irgendwelche Foreign
25:24
constraints zu zu zerstören, was man aber auch erst n bisschen
25:27
später dann gemerkt hat, wo man dann sich gedacht hat, OK warte
25:30
mal, wieso konnte ich zum Beispiel diese Entität löschen,
25:33
obwohl es ja eigentlich. Ne Verbindung zu einem anderen
25:37
Objekt gab was noch da ist. Also das dürfte eigentlich gar
25:39
nicht gelöscht sein, oder? Das wurde nicht mitgelöscht,
25:42
weil ne das sozusagen so ne Abhängigkeit auf das Objekt
25:44
hatte. Wenn ich das lösche lösche ich
25:45
auch das und das ist dann echt richtig schwierig, weil erstens
25:49
musst du es auf der Produktivdatenbank wieder fixen
25:51
ne und zweitens musst du erstmal checken, dass es da ist.
25:55
Wie lange dauert es bis du es checkst und ich fand auch
25:59
wirklich dieses Problem von Datenbankmigration was du
26:00
angesprochen hast ist n super heftiges Problem.
26:04
Was man eigentlich auch abtesten sollte, weil wenn du das nicht
26:07
abtestest kann kannst. Du kann deine ganze Software
26:10
wunderbar funktionieren, aber am Ende fliegt dir trotzdem alles
26:13
um die Ohren. Das ist find.
26:15
Ich sehr, sehr heikles Thema, weil du sagst Datenbanken
26:17
langweilig schalt ich aus, niemals ausschalten an dieser
26:20
Stelle. Nee, aber das ist halt genau der
26:24
Punkt, was bei uns ja auch Probleme gemacht hat ist weil so
26:29
sehr du quasi auf einer. In Memory Datenbank
26:32
beispielsweise arbeitest die Tests laufen lässt irgendwas
26:36
Hinzufügst, einträgst löscht, änderst.
26:38
Wie auch immer das mag alles funktionieren, aber gerade wenn
26:41
es so um Sachen wie Migration geht, hast du einfach das
26:44
Problem, dass es eine falsche Datenbank ist am Ende, es ist
26:46
nicht die Datenbank die produktiv läuft, es ist nicht
26:52
die Version, es ist nicht der Typ, es ist einfach nur eine
26:55
Nachbildung. Und das ist auch der Grund,
26:58
warum wir dann umgestiegen sind und gesagt haben, OK, nein, es
27:02
gibt Tools und Lösungen, die sind gut, die funktionieren gut.
27:05
Wir nehmen uns jetzt die Zeit und bauen das um, weil einfach
27:08
das Projekt, oder sag ich mal ja doch das ganze Softwareprojekt
27:14
immer größer wurde, immer mehr Bedeutung gewonnen hatte und
27:17
natürlich irgendwann gewisse Qualität fordert, sag ich mal
27:21
auch in der Testumgebung, gerade in der Testumgebung.
27:24
Und dann haben wir entschieden, dass wir sagen, OK, wir gehen
27:28
weg von der h 2 Datenbank, also die in Memory Datenbank hinzu,
27:33
einer echten Postquest Datenbank in der gleichen Version, wie sie
27:36
produktiv läuft. Und wie machen wir das ganze
27:39
Vollautomatisiert, dass es immer in unserer Test Automatisierung
27:43
Testumgebung mitläuft, automatisiert so rum und sind ja
27:49
letztendlich dann bei Testcontainers gelandet und
27:52
testcontainers. Oder Testcontainer allgemein
27:55
sind ne super Sache und das ist auch so die Hauptmotivation des
27:59
Themas, weil es einfach Integration Test super super
28:03
vereinfacht. Aber lass uns doch mal bevor.
28:08
Also es gibt ja bestimmt den ein oder anderen Zuhörer oder
28:10
Zuhörerin, die jetzt nicht weiß was testcontainer sind.
28:14
Also bevor wir jetzt über vor und Nachteile sprechen, magst du
28:17
mal grob anreißen. Was da eigentlich dahinter
28:22
steckt und ich finde es ganz cool, dass du das Beispiel
28:24
gebracht hast mit dem Skript, bevor die Tests starten.
28:29
Ne, dass du n Skript schreibst. Docker compose hier und da, weil
28:33
ich finde das ist quasi so ne Vorstufe, dass ihr gesagt habt,
28:37
OK, das Problem ist da, weil der eine hat die Container nicht
28:39
laufen, der andere hat sie noch gar nicht drauf, die Docker
28:42
Images oder Container am Laufen, wie auch immer, jeder ist aber
28:45
irgendwo an einem anderen.in seiner Umgebung.
28:48
Und dann habt ihr angefangen, Skripte zu schreiben, um das zu
28:51
automatisieren. Genau, und jetzt kommt
28:54
Testcontainer. Jetzt kommt Testcontainer also
28:58
Testcontainer ist nicht einfach nur n Container, den man zum
29:00
Testen nimmt, also sowohl ja als auch nicht unbedingt, weil das
29:04
ist der Name von der Library, so kann man sich das vorstellen,
29:07
das heißt Testcontainer ist einfach.
29:09
Ne Library die du halt nutzen kannst um halt eben genau das so
29:14
zu machen oder diese das Problem zu lösen oder die Probleme zu
29:18
lösen, die wir gerade so n bisschen geschildert haben oder
29:20
diese Painpoints es erlaubt nämlich am Ende, dass du sagst,
29:24
du hast Dockercontainer, also es arbeitet mit Dockercontainer,
29:27
wenn du nicht weißt jetzt was n dockercontainer ist.
29:29
Liebe zuhören lieber Zuhörer oder sagst ja ich weiß es zwar,
29:32
aber irgendwie interessiert mich das noch mal.
29:33
Wir haben ne Folge ausschließlich über
29:35
Dockercontainer, also hör da gerne rein und dann hör jetzt
29:38
hier weiter, oder? Mach hier einfach weiter danach.
29:41
Genau, aber bis gleich, aber es nutzt halt Dockercontainer und
29:48
du kannst halt in diesen Dockercontainern entsprechende
29:51
Dinge starten, die du halt haben möchtest.
29:54
Zum Beispiel sowas wie ne Post SQL Datenbank.
29:58
Ich weiß nicht wie nennt man das Postgres QL postgres?
30:01
Post ich sag mal postgres. Ja, jetzt kommt es
30:06
wahrscheinlich auch der ein oder andere und sagt.
30:08
Nein. Ich find das ist ja, es ist, es
30:11
ist schwierig sich auf eine wie sagt man auf dem Naming zu
30:15
einigen bei sowas, bei solchen Sachen, aber du kannst zum
30:18
Beispiel so ne Datenbank nehmen und die starten, das heißt du
30:20
hast am Ende wirklich in deinen Testcontainer zum Beispiel
30:24
wirklich ne Datenbank drin die genauso ist 1 zu 1 wie die
30:27
Datenbank die du auch ja lokal lokal Remote auf prot.
30:34
Wie auch immer irgendwo laufen lassen hast.
30:36
Ne das heißt du kannst. Dir es auch vorstellen und
30:39
sagen, gut, du musst jetzt nicht unbedingt, weil Tina ja meintest
30:41
ne Vorstufe, du musst jetzt nicht unbedingt sagen, du nimmst
30:45
n testcontainer. Du kannst natürlich auch n
30:47
eigenen Dockercontainer schreiben, wo du genau ne Post
30:50
postgress Datenbank aufsetzt, was auch immer, geht ja auch du
30:55
kannst es dir selber nachbauen oder du nimmst halt eben diese
30:57
Library, die dir halt ne Menge abnimmt, ja weniger Arbeit, so
31:00
kann man sich das vorstellen und im Endeffekt ist es dann nämlich
31:04
genau so, dass die Tests dann auch wirklich.
31:08
Also diese Container automatisch starten.
31:11
Das heißt, du lässt deine Tests laufen und deine Container
31:15
fahren hoch, deine testcontainer, wo halt eben
31:17
deine ganzen Abhängigkeiten drin laufen, die du dir halt
31:20
zusammenbastelst, so wie du sie brauchst und wie zum Beispiel
31:25
halt eben die postgres Datenbank.
31:28
Und dann laufen deine Tests. Also erstmal werden die
31:30
Container hochgefahren, deine Tests starten und deine
31:34
Integration kann sozusagen genau in deine Testcontainer ja
31:41
reinintegrieren Reinintegrieren deine Integration Tests nutzen,
31:46
dann die Testcontainer am Ende genau und.
31:51
Wenn die Tests halt fertig sind, werden diese Testcontainer auch
31:53
wieder gelöscht. Logischerweise, das heißt du
31:54
hast auf jeden Fall immer wenn du diese Tests laufen lässt und
31:56
wenn die Tests vorbei sind, hast du immer wieder einen clearen
31:59
cleanen Zustand, mit dem du dann am Ende wieder arbeiten kannst
32:04
und du musst dich nicht darum kümmern wie Tino, wie du es ja
32:07
auch so schön meintest. Man muss jetzt nicht erstmal die
32:10
irgendwie einen Docker compose abmachen.
32:12
Gucken, dass die Dockercontainer alle soweit richtig sind et
32:15
cetera PP, sondern du sagst halt einfach nur ich lass es.
32:18
Also Start ist los, es geht los, es wird automatisch abgeräumt,
32:22
alles fertig. Genau das ist halt ne super
32:25
Sache, weil diese Container wirklich für den Testlauf
32:28
erschaffen werden. Verwendet werden und abgeräumt
32:31
werden und. Du musst dir auch nicht mal
32:35
wirklich Gedanken drüber machen, auf welchem Port läuft das und
32:39
so weiter weil das wird kann dir alles abgenommen werden.
32:41
Du kannst natürlich auch in Konfiguration sagen Nein.
32:45
Keine Ahnung, ich kann nur diesen Port dafür nehmen.
32:47
OK, aber das Schöne ist, wenn du es automatisiert machst, dann
32:51
nutzt er halt einen freien Port, sucht sich den und alles leitet
32:54
automatisch dahin und du musst dir da gar keine Gedanken zu
32:57
machen. Ja also es der Ablauf ist
32:59
wirklich simpel und die Konfiguration ist auch simpel,
33:02
gerade wenn du jetzt sagst ich möchte einfach nur nen
33:05
Dockercontainer also mein Testcontainer soll den
33:08
Dockercontainer mit einem Image haben wo ne Postgress in der
33:11
Version XY drin ist und ich sage.
33:14
Der User ist das Passwort ist das und die Datenbank heißt so
33:18
und so fertig. Ja.
33:20
Die URL dafür wird automatisch zusammengesetzt.
33:23
Port wird entschieden wie gesagt, der Port wird natürlich
33:26
in der URL auch berücksichtigt und dann läuft das Ding, also es
33:29
ist wirklich so einfach wie es sich anhört an der Stelle.
33:33
Klar, es gibt immer komplexe Fälle, wenn ich viele Partys hab
33:37
die ich da drin abbilden möchte, muss ich natürlich mehr
33:40
Konfiguration schreiben als jetzt so ne einfache Datenbank.
33:44
Aber ich kann dann, wenn ich die echte Datenbank hab, zum
33:46
Beispiel auch einfach alle meine Flyway Skripte da drüber jagen,
33:49
was ne super Sache ist. Ne?
33:50
Also die komplette Migration kann da einmal durchlaufen.
33:54
Ne von den ersten Skripten die die Datenbank Tables beispiels
33:57
beispielhaft beispielhaft aufbaut, meine Güte.
34:01
Bis hinzu Migration, die später stattfindet, dass Tables wieder
34:04
weg können, sich ändern. Wie auch immer, aber ich kann
34:06
die ganze Historie noch mal da durchjahren, was ne super Sache
34:10
ist, gerade bei so Migration. Ja und?
34:12
Spätestens dann, ja spätestens dann, wenn du sagst, du hast
34:15
deine Datenbankmigration, die durchläuft deine ganzen flyrate
34:18
Skripte. Liebe zu lieber zu ganz kurz,
34:21
falls sich flyray oder so interessiert wie das
34:22
funktioniert, können wir auch gerne Folge drüber machen,
34:25
ansonsten setzen wir jetzt einfach voraus, dass man weiß,
34:28
was flyray ist. Aber Datenbankmigration ist halt
34:32
so, wenn du deine Datenbasis n bisschen ändern möchtest, dann
34:35
kannst du es nicht einfach so machen, sondern du musst halt
34:37
was dafür tun oder irgendwas dafür nutzen und dafür kann man
34:40
zum Beispiel Flyray nutzen und das Gute ist aber, wenn du das
34:43
durchlaufen lassen kannst und deine Daten deiner Tables
34:46
veränderst, sozusagen also deine, ich sag mal deine
34:51
Tabellenköpfe zum Beispiel oder was auch immer.
34:54
Und dann deine Systemtests zum Beispiel laufen lässt.
34:56
Dann kannst du ja zum Beispiel wirklich auch checken, ob
34:59
bestimmte Dinge abgeräumt werden können oder eben nicht, weil zum
35:04
Beispiel, wie ich meinte, Foreign Constraints hinterher
35:07
aus Versehen gelöscht wurden oder nicht ne, weil genau das
35:11
war ja damals das Problem, was dann sozusagen aufgetreten ist.
35:14
Und das sowas kann man natürlich auch.
35:17
Darüber checken, das ist natürlich super, musst du
35:20
natürlich auch n bisschen gucken, dass du deine Tests
35:22
sozusagen dementsprechend gestaltest, dass du auch
35:24
wirklich checkst oder abtestest cirtest, dass halt genau das
35:29
auch so sein muss, ne, aber das ist natürlich dann testqualität
35:33
am Ende, aber das hilft natürlich dann ne.
35:38
Genau, und dadurch hatten wir natürlich jetzt einfach den
35:40
Vorteil, dass wir gesagt haben, OK, wir haben die echte
35:42
Datenbank natürlich nicht mit den echten Daten, aber dann die.
35:45
Wie eingangs eingangs erwähnt, wollen wir sie ja auch nicht
35:48
haben. Wir wollen ja auch nicht auf der
35:49
echten Datenbank überall testdaten reinschreiben, sondern
35:52
wirklich ne Datenbank hochfahren, testdaten
35:54
Raufschreiben löschen, verarbeiten, wie auch immer und
35:57
danach abräumen und dann wieder von vorne in dem Zustand
36:00
starten, dass alles bei 0 ist. Ja, und das kannst du produktiv
36:03
halt nicht machen, aber wir haben jetzt den Punkt erreicht,
36:05
dass es die echte Datenbank ist. Am Ende ja.
36:08
Und wenn man sich jetzt ganz kurz, vielleicht ist es noch
36:10
nicht ganz, möglicherweise nicht ganz klar geworden, aber wenn
36:13
man sagt, ja OKH 2 Datenbank nette Sache, ist ja ne Datenbank
36:17
so die Tests laufen, wieso sollte es denn jetzt zum
36:20
Beispiel nicht laufen, also wieso laufen die auf der H 2
36:22
Datenbank aber zum Beispiel auf deiner Produktivdatenbank nicht
36:25
und warum löst es das Problem, dass du wirklich die 1 zu 1
36:28
Datenbank nimmst? Also genau, und das ist auch der
36:31
Grund, warum wir am Ende zu dem Problem gekommen sind und
36:35
umgestiegen sind, weil spätestens wenn ich bei
36:39
Migration in den flyway skripten, ja, also ich kann halt
36:42
gewisse Features nutzen, Datentypen auch zum Beispiel
36:47
nutzen, die Postgress unterstützt ja die, die auch die
36:51
Welt einfacher macht auf Datenbankebene aber die h 2 zum
36:55
Beispiel nicht oder umgedreht umgedreht ist halt noch.
36:57
Noch wilder, weil wenn denn die h 2 sagt, ja klar kann ich
37:02
machen kein Thema und deine Produktivdatenbank aber sagt
37:05
kenn ich nicht, kann ich nicht verarbeiten, kann ich nicht
37:07
serialisieren was auch immer das ist halt n richtiger worst case,
37:11
weil dann steht das ganze ja und so kam halt einfach das eine zum
37:17
anderen, dass man sich dachte wir divergieren so stark.
37:21
Dass es nervt, ja, dass ich mir nicht mehr sicher sein kann und
37:24
nicht mehr die Überzeugung von meiner Testumgebung hab, dass
37:27
sie wirklich mir gewährleistet, dass alles gut ist am Ende und
37:30
alles läuft und dann hat man jetzt ne Library wie
37:34
Testcontainers die sagt Ey ich integriere das komplett in deine
37:37
Test Suite muss gar nichts machen, du konfigurierst mich
37:40
was erstmal ne gute Sache ist, weil es total in Richtung
37:43
Infrastructure is code geht. Ne, weil es ist ne versionierte
37:46
Beschreibung deiner Infrastruktur in der
37:49
Testumgebung, die reproduzierbar für alle ist was super ist und
37:55
am Ende laufen die Tests genauso klar.
37:57
Du hast so n paar Einschränkungen im Sinne von
38:01
Laufzeit, zum Beispiel weil ich glaub das kann sich jeder denken
38:06
einfach was in Memory laufen zu lassen und hochzufahren geht
38:09
super schnell hier an der Stelle müssen Container.
38:13
Erzeugt und hochgefahren werden. Sie müssen abgeräumt werden.
38:16
Man hat natürlich ne gewisse Zugriffszeit da drauf, das heißt
38:20
der Test an sich wird n bisschen langsamer und die Test Suite zu
38:25
starten, das heißt diesen ganzen Aufbau zu machen dauert
38:28
natürlich wesentlich länger, ja. Ja, je nachdem wieviel man da
38:32
hochfährt. Also ich sag mal, wenn es jetzt
38:34
einfach nur n Testcontainer mit einer Datenbank ist, dann ist
38:38
das voll überschaubar und völlig in Ordnung.
38:40
Ja weil da sind die Benefits und die Vorteile einfach riesig im
38:43
Vergleich zu dem erhöhten Zeitanteil, den man dadurch hat.
38:47
Ja, richtig. Also das Ding ist.
38:50
Es ist ja wie gesagt auch nicht unbedingt notwendig, dass man
38:53
sagt, Ey, du willst jetzt irgendwie deine Software, deine
38:56
Anwendung abtesten. Nimm auf gar keinen Fall eine h
39:00
2. Ja, die Frage ist ja immer nur,
39:03
also es ist ja, es ist logisch zu sagen, du kannst es natürlich
39:06
erstmal mit h 2 machen, es geht schnell, du kommst erstmal
39:09
schnell ins Doing, das ist alles in Ordnung, alles gut, du hast
39:12
erstmal testsie Daten, du hast wahrscheinlich noch nicht einmal
39:14
eine Migration machen müssen deiner Daten, aber wenn du
39:20
irgendwann mal eine Datenbank gehostet hast, wo du Daten drin
39:22
hast, wo du zum Beispiel die Migration machen musst.
39:25
Dann willst du ja zum Beispiel auch wissen, funktioniert das,
39:27
weil es gibt tatsächlich eine Sache, die ich irgendwie, ich
39:32
weiß gar nicht, ob es so schlimm ist, aber ich finde es
39:34
persönlich schon recht schlimm, wenn du ne Datenbankmigration
39:37
machst, die fehlschlägt, weil dann kannst du nicht einfach mal
39:40
soeben ohne Probleme sagen, OK, ich mach ich, ich fix das mal
39:45
eben, sondern da, da hängt schon n bisschen was dran und wenn du
39:49
dann aber ne deswegen am Anfang ist es OK das zu machen, du hast
39:52
noch eigentlich nicht unbedingt ne Daten.
39:54
Bankmigration du hast vielleicht nutzt vielleicht noch nicht mal
39:58
flyway zu dem Zeitpunkt ne, dann ist es völlig in Ordnung, aber
40:01
wenn du irgendwann an n Punkt kommst wo du dir denkst, ja ich
40:04
weiß nicht, ich glaube ich brauch ne Migration und
40:07
vielleicht zumindest zu dem Zeitpunkt wo das erste Mal die
40:09
Migration failed, ja. Die aber wahrscheinlich noch
40:13
relativ früh ist. Und es ist noch nicht so
40:14
schlimm. Du kannst deine Datenbank locker
40:15
noch mal komplett abräumen und neu aufsetzen, alles gut, ja, da
40:19
sind noch nicht so wichtige Daten drin, aber zumindest an
40:22
dem Zeitpunkt sollte man sich halt überlegen, na das
40:24
funktioniert nicht mehr ganz so mit der H 2 Datenbank und dann
40:27
kann man umsteigen und dann kann man zum Beispiel eben
40:30
Testcontainer nutzen. Also das ist auf jeden Fall so.
40:34
Ne, weil man sich ja vielleicht jetzt hinstellen sagt.
40:36
OK, ich mach das jetzt sofort so, muss nicht sein, aber das
40:39
wäre so n Anzeichen, weil man sagt es wäre jetzt vielleicht
40:42
hilfreich und sinnvoll darauf. Umzusteigen?
40:45
Ja, im Prinzip war es ja genauso der Werdegang bei unserem
40:48
Projekt jetzt, was wir als Beispiel nehmen, ne, dass wir
40:51
gesagt haben, OK, wir nehmen in Memory für Tests einfach erstmal
40:54
Test schreiben gut funktioniert, dann lief die Datenbank
40:58
produktiv und das ganze Backend ist produktiv gegangen so h hier
41:02
bei den Daten. Lass das noch mal die ganze
41:05
Struktur umbauen. Ne.
41:08
Ja OK, ist ja eh noch nichts drin, so kannst du abräumen
41:12
machst du neu, lösch da halt die Daten, Lösch dir die Datenbank
41:15
tut nicht weh am Anfang aber du kommst zu einem Punkt wenn es
41:18
halt ne Weile produktiv lief, also wirklich produktiv ist dann
41:22
am Ende sag ich mal, dass du genau das nicht mehr da darfst
41:25
und nicht machen möchtest. Und dann denkst du dir so, hm,
41:28
jetzt brauchen wir Migration. Na gut, da haben wir Flyway mit
41:30
reingenommen. Ja jetzt weichen wir irgendwie
41:33
schon ziemlich ab von der H 2 Datenbank zu unserer echten
41:36
Postquest testcontainers ja, und genauso entwickeln sich Projekte
41:41
und das sagen wir ja auch immer wieder ne.
41:45
Auch hier greift irgendwie so das globale Jagni You Ain't Go
41:49
Need it nicht. Also mal klar kann man sagen,
41:52
wir machen im Projekt was wird es, das wird ne MVP gut, alles
41:56
klar, wir brauchen folgendes wir müssen das machen hier und da
41:58
und dann müsste unsere Infrastruktur aussehen, die
42:00
Pipeline wird das und das machen können, also machst du ja nicht
42:04
sowas iteriert sich sowas entwickelt sich weiter und so
42:07
finde ich kann man halt immer gerade an dieser Motivation die
42:11
wir jetzt gegeben haben gut erkennen wann?
42:13
Wird sowas notwendig? Warum macht man das irgendwann?
42:17
Sind halt super wichtige Punkte und ich find halt Migration was
42:20
du meintest geht mir genauso, ich find es n absoluter Pain
42:25
große Migration zu machen wenn die Failen nervt ist n ungutes
42:30
Gefühl wird man auch n bisschen unruhig, geht vielleicht anderen
42:33
Leuten anders, aber mich macht das auch unruhig bin ich ehrlich
42:37
klar du hast jetzt sag ich mal, je nachdem in welcher
42:41
infrastrukturlandschaft du unterwegs bist, ne gibt es
42:44
natürlich Möglichkeiten Sachen zurückzusetzen und so weiter
42:48
alles cool, aber trotzdem kommt doch erstmal dieser Moment wo du
42:51
denkst verdammt noch mal, warum hat diese Migration nicht
42:55
geklappt, warum die Oh Gott nein was ist oh nein oh nein, das
42:59
kann ich so nicht machen oh nein weißt du nervt ne ganz klar bin
43:02
ich ganz bei dir. Ja, also ich weiß ja, dass du
43:06
dann auch im Normalfall kannst du nicht einfach sagen, ich,
43:09
ich, ich verändere einfach diesen Migrationsstep, weil er,
43:12
weil dieser eine Migrationsstep, der dazu geführt hat, dass es
43:15
failed ja schon in der Migrationshistory drin ist, ne,
43:18
also du müsstest halt, du musst halt, also du hast halt
43:21
Möglichkeiten, die hast du das zu fixen, aber es ist halt
43:25
deutlich anstrengender und nerviger als zu sagen.
43:29
Oh, warte mal, diese Funktionalität da ist n Bug
43:31
drin, warte ich schreib n Test dazu.
43:33
Der Test ist tatsächlich rot, ich fix ich fix die
43:35
Implementierung Test grün alle Tests grün und los ne neuer
43:40
Commit alles in Ordnung das das das ist noch das ist irgendwie
43:44
finde ich noch einfacher aber wenn du wirklich merkst oh warte
43:47
mal die Datenbasis funktioniert nicht mehr so wie sie soll zum
43:51
Beispiel also entweder das entweder migrations Skript
43:54
schlägt Fail dann hast du zumindest.
43:58
N Punkt auf der Pipeline wo du dir sagst im Optimalfall OK, das
44:01
hat nicht funktioniert, wir müssen was tun.
44:03
Ja im besten Fall irgendwo auf auf einer anderen Instanz bevor
44:07
es auf Prod geht, damit du das schon mal sowieso schon abfängst
44:10
OK, aber wenn du irgendwas hoch auf Tools wie flyway ne aber
44:16
wenn du aber wenn du wirklich mal sowas hast wo du sagst es
44:19
funktioniert sogar, es geht durch Flyway funktioniert alles
44:22
gut aber du machst was kaputt womit du gerade nicht rechnest.
44:27
Und du kannst es nicht ab, hast es vielleicht nicht abgetestet,
44:29
weil du deine flyray Migration vorher nicht abgetestet hast.
44:32
Nicht so richtig, und deine automatisierten Tests sozusagen
44:35
nicht anhand von dieser Basis deiner Migration sozusagen das
44:39
testen würde. Und dann hast du irgendwelche
44:43
fehlerhaften Verknüpfungen, constraints, was auch immer in
44:46
deiner Datenbank, das ist scheiße, das ist wirklich ne
44:48
Sache, die will man nicht haben und deswegen ist das halt
44:52
wirklich wichtig. Und natürlich steht jetzt diese
44:53
Datenbank, die wir hier sehr stark in den Fokus rücken.
44:56
Für Testcontainer stellvertretend für externe
45:00
Services, die du mit Test testcontainers halt eben Host.
45:04
Also nutzt absolut absolut. Also das betrifft natürlich
45:07
nicht nur Datenbanken, es passt halt nur rein, weil wir es ja
45:10
erst über die letzten Wochen quasi diesen Weg wieder gegangen
45:14
sind und wieder festgestellt haben, wie sowas sich
45:17
weiterentwickeln kann. Dann noch der Wunsch kam dieser
45:19
Folge, deswegen ist es natürlich jetzt immer als Beispiel die
45:22
Datenbank, aber du hast natürlich recht, wie eingangs
45:25
erwähnt. Das betrifft alle Abhängigkeiten
45:29
nach außen. Ja, alles was das hört.
45:31
Party ist auch zum Beispiel lästig, Search, hat man erwähnt,
45:33
kann man damit auch ja nutzen sozusagen oder irgendwelche APIS
45:39
und ich finde diesen riesen Vorteil, die müssen wir auch
45:41
noch mal ganz klar sagen, warum das ganze ja gut kann ich ein 2
45:45
Tests mehr schreiben, ja. Sollte man erstmal also
45:51
Integration. Tests sind super wichtig, aber
45:54
der Vorteil liegt ja nicht mal darin jetzt dass ich Integration
45:58
Tests schreiben kann, konnte ich vorher auch, hatten wir auch die
46:02
Tests und das ist ja der Witz jetzt an der Stelle oder sag ich
46:05
mal das coole, die Tests haben sich ja nicht geändert, die
46:09
gehen bloß nicht gegen ne in Memory Datenbank sondern einfach
46:12
gegen ne echte und sind weiterhin grün gelaufen aber.
46:16
Die sind dadurch viel realistischer geworden, weil es
46:22
ne echte Datenbank dahinter ist. Es ist keine Simulation mehr, es
46:25
ist auch keine Fake Datenbank. Jetzt ist natürlich die Frage,
46:28
wo bin ich in meiner Software wo ich teste ne Stichwort Unit Test
46:32
noch mal wenn ich den Service teste dann kann ich auch n Fake
46:34
Repository dahinter haben, ist auch sehr angenehm und sollte
46:37
man auch machen, ist auch ne gute Practice zu sagen ich hab
46:40
ne. Ne ne, da also ne Repository
46:43
stellvertretend für meine Datenbank.
46:45
Ja und hab ne echte Implementierung und ne Fake
46:48
Implementierung, dann nehm ich natürlich die Fake
46:50
Implementierung wenn ich auf Unit testebene wie wir vorhin
46:53
meinten zum Beispiel n Service da drüber geschaltet abtesten
46:56
möchte komplett richtig ja aber wenn ich irgendwann auf
46:59
spätestens Integration Ebene bin möchte ich ja testen ob es
47:04
wirklich in die Datenbank reingeht richtig ob ich genau
47:07
diese Daten auch wieder richtig auslesen kann und dann.
47:11
Muss ich sagen, realistischer geht es dann halt einfach nicht,
47:13
außer natürlich auf der echt live laufenden, aber das wollen
47:16
wir nicht, da haben wir gesagt, da ist die rote Linie, ja ich
47:20
mein das Beste ist halt genau dafür zu sorgen und das sollte
47:23
halt auch das Ziel sein zu sagen.
47:25
Wie kann ich denn mein meine ganzen, ich sag mal meine ganze
47:30
Testumgebung so gestalten, dass sie halt eben wirklich möglichst
47:34
identisch oder zumindest annähernd an die protte Umgebung
47:37
rankommt? Ne, dass man halt wirklich das.
47:39
Das Verhalten halt eben auch hat, weil je weiter dein
47:42
Verhalten von der echten Instanz, auf der dein, dein
47:46
Service, deine Anwendung auch noch mal läuft, abweicht, desto
47:50
mehr kann natürlich auch irgendwas schiefgehen, womit man
47:52
auch gar nicht rechnet und was man dann natürlich auch deutlich
47:55
schwieriger wieder, ich sag mal greifen kann, wenn du in in die
48:00
Fehlersuche gehst, ne? Ja, absolut.
48:06
Den Punkt, den du vorhin meintest mit jeder Mitarbeiter
48:10
muss ja, also vergiss vielleicht was auszuführen und so weiter
48:13
oder hat denn vielleicht die Container nicht, ist natürlich
48:15
der andere große Vorteil an der Stelle, um das noch mal klar auf
48:19
den Punkt zu bringen, ich hab halt keine lokalen
48:22
Installationen die notwendig sind und ich hab ne
48:24
reproduzierbare Umgebung, es ist einfach Infrastructure is code
48:27
an der Stelle. Und jeder Entwickler hat im
48:30
Endeffekt die gleiche Umgebung, wenn er die Tests laufen lässt
48:33
und nach den Tests ist das alles auch wieder sauber abgeräumt.
48:37
Es ist halt vollautomatisiert es einfach.
48:40
Ja es ist halt super angenehm es einfach zu verwenden.
48:43
Ja gut, jetzt kann man sagen eine lokale Installation muss es
48:48
geben, ich muss natürlich irgendwie dockercontainer laufen
48:50
lassen können auf mein System wenn ich es lokal laufen lassen
48:52
möchte ja OK fairness muss man sagen.
48:56
Docker ist Voraussetzung, weil Testcontainer einfach auf Docker
48:59
aufsetzt und damit die Container erzeugt.
49:01
Ja, jetzt ist natürlich die Frage, auf welchem System, also
49:06
auf einem Dev System, wo entwickelt wird, wo noch nicht
49:09
Docker drauf ist. Wird man wahrscheinlich nicht so
49:11
viele finden, deswegen denke ich kann man damit leben.
49:14
Ja richtig, das ist auf jeden Fall, aber ich sag mal so,
49:18
angenommen du hast den, also die.
49:22
Die Beschränkung ja und wirklich sagst wo du, wo du wirklich
49:25
sagst. Ja es darf kein Docker verwendet
49:28
werden, dann ist es natürlich definitiv ne Sache wo man sagt
49:30
gut dann ist Testcontainer definitiv nicht nicht geeignet.
49:33
Ne das muss man halt dazu sagen, angenommen du hast diese
49:35
Situation. Genau.
49:38
Es ist halt einfach die Bedingung, ja, also die
49:41
Voraussetzung muss halt gegeben sein.
49:45
Ja, wie stehst du zu dem Thema, sie sind langsamer, ich hatte ja
49:49
gesagt, das kann man gerne in Kauf nehmen.
49:51
Es ist natürlich einfach die Frage, wieviel Systeme fahr ich
49:55
hoch, wie viele muss ich wirklich hochfahren.
49:57
Man muss halt wie gesagt differenzieren, brauche ich
50:00
diese diesen Grad des Realismus oder kann ich halt sag ich mal
50:07
es doch gut abtesten mit Fakes, mogs oder auch irgendwelche in
50:11
Memory Lösung aber. Also aus meiner Sicht sind doch
50:16
die Benefits größer als jetzt diese Dockercontainer da
50:19
hochzufahren. Ich mein, Ihr habt euch ja
50:21
damals auch aktiv dafür entschieden.
50:23
Ja, die Frage ist natürlich immer, also es gibt ja zum
50:26
Beispiel Testpyramide, wo man sagt, du hast sehr viele
50:28
unitests, du hast weniger Integration Test als Unitests
50:31
und du hast noch weniger System Test als Integration,
50:33
Integration ey, was hab ich denn heute Integration?
50:36
Integration klingt supergeil. Es tut mir leid.
50:41
Und das ist natürlich auch jetzt nicht unbedingt aus der Luft
50:43
gegriffen. Das ist natürlich nicht
50:45
verkehrt, wirklich zu sagen, dadurch, dass sie halt eben
50:47
langsamer sind, ist es natürlich sinnvoller, mehr Unit Tests zu
50:51
haben, aber da muss man natürlich auch wieder sagen,
50:54
einfach nur mehr Unit Tests zu haben um der Unit Test willen
50:58
bringt auch nichts ne wichtig ist oder dass das der Kernpunkt
51:02
an dieser Stelle es ist. Es muss wichtig sein oder
51:06
möglich sein, dass man möglichst schnell.
51:09
Fehler erkennt. Das heißt, wenn du sag ich jetzt
51:11
mal n bestimmtes Verhalten mit einem Unit Test abfangen kannst
51:15
oder abtesten kannst wofür du keinen Integration Test
51:19
brauchst, dann mach das so, dann dann hilft dir halt das geht ja
51:22
nicht genau dann hilft dir der Integration Test nicht genauso
51:24
mit e to e tests ne System test e to e Test nennst wie du
51:28
möchtest. Du brauchst jetzt zum Beispiel
51:30
nicht alle Unit Tests noch mal mit.
51:32
Integration, Tests, Abzutesten und noch mal mit E to e Tests
51:36
bringt dir gar nichts, sondern wirklich an der Stelle zu sagen,
51:40
du hast jetzt zum Beispiel die Logik, die wird Abgetestet über
51:42
Unit Test. Super Sache, aber funktioniert
51:44
denn auch wirklich die Connection zu einer Datenbank?
51:46
Werden denn richtig die entsprechenden Entities in deine
51:50
Datenbank reingeschrieben? Ja gut, dafür brauchst du halt
51:53
deine Integration Tests und wenn du dann aber zum Beispiel sagst
51:56
gut, ich brauche gar nicht so viele in Unit Tests und
52:00
Integration Tests. Dass du wirklich ne Pyramide
52:03
hast, sondern vielleicht ne in Quadrat, dann ist es so die
52:08
wichtigste Regel oder die wichtigste Metrik an der Stelle
52:11
ist, wie stark kann man sich darauf verlassen und das ganze
52:13
kann ja auch n bisschen wachsen und es kommt halt auch Erfahrung
52:17
mit hinzu, ne weil irgendwann kommst du halt an einem Punkt wo
52:21
du dir vielleicht erst, also am Anfang denkst du dir vielleicht
52:23
ja, was mach ich denn jetzt weiß ich nicht, sollt ich das lieber
52:25
so machen oder so. Mach es einfach erstmal und dann
52:28
lernst du daraus und dann guckst du und kriegst die Erfahrung, wo
52:32
du beim nächsten Mal sagen kannst.
52:33
Dafür brauch ich aber gar keinen Integration Test.
52:36
Dafür kann ich n Unit Test nehmen oder andersrum.
52:38
Wie auch immer ne, aber man muss sich jetzt nicht unbedingt auf
52:41
ne Testpyramide festhalten, aber sie ist auch nicht aus der Luft
52:44
gegriffen so das mein ich. Das stimmt, das stimmt absolut.
52:50
Ich finde, dass das Verhältnis. Was also, welche Art, welche
52:56
Tests ist auch alles projektabhängig und genauso ist
53:00
es auch projektabhängig ob testcontainer Sinn machen oder
53:03
nicht. Ne, jetzt war unser Beispiel
53:04
Backend mit einer Datenbank war in dem Fall sinnvoll, wenn jetzt
53:10
natürlich ne sehr kleine Datenbank ist oder kaum
53:13
Migration stattfinden obwohl das auch immer so ne Sache ist weiß
53:17
ich nicht, früher oder später kommt man sicherlich an den
53:20
Punkt wo man sagt wir müssen mal n bisschen was ändern an der
53:22
Datenbank. Aber sei mal dahingestellt.
53:24
Es gibt natürlich auch ganz andere Fälle, ne, also wenn ich
53:27
jetzt zum Beispiel n Projekt hab, was auf Microservices
53:30
aufsetzt, also ne, dass man sagt, OK, unsere Architektur von
53:34
dem gesamten Produkt ist jetzt Microservices und ich bau mir so
53:38
ne Landschaft auf, dann ist das auch n super Fall, weil dann
53:41
will ich ja einen Service abtesten wie er mit anderen
53:44
Services arbeitet ne und wie der sich integriert in diese
53:48
Landschaft und dann kommen wir auch an den Punkt wo das echt
53:50
Sinn machen kann ne oder? Was ich auch mal gesehen hatte
53:55
ist auch ne coole Sache zu sagen, ey ich fahr einfach in
53:58
einem Container zum Beispiel nen Chrome oder Firefox hoch und
54:03
mach so Millenniumtests beispielsweise ne ist ja auch ne
54:07
Möglichkeit, dass ich halt wirklich sage ich habe jetzt n
54:09
Browser sozusagen. Also ich habe so richtig n
54:12
Container wo darin das läuft ja gibt es halt unterschiedlichste
54:17
Möglichkeiten ne. Und ich denke, wir haben da auch
54:20
jetzt genug genannt, um sich da das ganze Mal so vorstellen zu
54:23
können. Aber ich finde, egal wo man es
54:26
verwendet, es gibt halt so n paar Best Practices oder
54:30
Erfahrung die man mitgeben kann und das würde ich gerne jetzt am
54:34
Abschluss noch machen, das ist halt so mal n ganz nettes Take
54:38
Home Ding so ne. Also wir haben jetzt zum
54:41
Beispiel gesagt so fixe Ports einstellen für so n Container
54:45
wie der erreichbar ist. Besser nicht, ne, weil
54:48
Testcontainers bringt ja schon ne Automatismus mit zu sagen ich
54:51
suche mir n freien Port und ich gebe den auch wieder frei wenn
54:54
die Tests durch sind. Ich kann ja für jede
54:58
Testumgebung das ganze hochfahren, ich kann das ja auch
55:01
parallel betreiben, das geht ja alles theoretisch ne umso
55:04
dynamischer muss ich ja meine Config am Ende machen ne klar
55:08
wenn ich jetzt sage sag ich mal ich hab eine Testsuite.
55:11
Fahr ich das einmal hoch? Alle Tests laufen durch, Fahr
55:14
das runter fertig, aber wie du ja meintest, sowas kann ja auch
55:18
gesplittet werden oder nur n Teil läuft wie auch immer wenn
55:21
ich so in so n parallelen Betrieb komme ist es natürlich
55:23
umso wichtiger das dynamisch in der Conflict zu halten und das
55:27
ist halt zum Beispiel so n Punkt.
55:29
Dass man da drauf achten sollte auch, dass der Host nicht
55:32
unbedingt Hard gecoded ist oder die URL, das kann sich selbst
55:37
zusammensetzen, also nutzt man das auch.
55:39
Ne, das klingt so wie das ist Free Lunch.
55:41
Also ich würd es halt auch einfach nutzen.
55:43
An der Stelle ist immer noch was anderes, wenn ich nicht
55:45
beispielsweise jeden Port nutzen kann, ja weil du ja auch
55:49
meintest, vielleicht kann man ja doch gar gar nicht verwenden,
55:51
soll vorkommen, soll auch vorkommen, dass nur gewisse
55:54
Ports möglich sind, dann ist natürlich ne andere Sache, aber
55:57
die CONFIG ist möglich. Und eine Sache tappt man gerne
56:01
rein. Das würde ich gerne auch
56:02
mitnehmen. Du grinst schon so, wenn ich das
56:07
Image nehme, also wie gesagt, es ist ja wirklich simpel, ich sag
56:10
einfach bau mir mal n Container auf mit einem postgress Image
56:14
und Version sowieso kann ich bei sowas ja auch zum Beispiel
56:18
Latest angeben. Ja gib mir doch einfach die
56:20
letzte Version. Ja.
56:22
Ja, klingt ja erstmal gut, immer schön State of the Art sein.
56:26
Welches Problem haben wir aber dann an der Stelle?
56:28
Und da tappt man wirklich gerne mal rein.
56:31
Na ja, mit latest. Also du hast halt auch andere
56:34
Abhängigkeiten, ne mit Latest. Also das kann halt sein, dass
56:37
irgendeine Abhängigkeit in deiner Latest Version von denen,
56:40
also ich sag mal, du hast ja irgendwie n Container und n
56:43
Container besteht aus Abhängigkeiten und Latest ist
56:46
wahrscheinlich die aktuellste Abhängigkeit, was aber am Ende
56:50
bedeutet. Dass du vielleicht irgendwie ne
56:52
falsche Note Version hast, möglicherweise die vielleicht
56:55
gar nicht mehr passt für das was du willst.
56:57
Oder zum Beispiel, wenn wir jetzt bei Datenbanken waren,
56:59
dass du zum Beispiel ne postgress Datenbank hast, die
57:02
halt jetzt auf einmal ne andere Version hat als deine Datenbank,
57:05
die du tatsächlich produktiv nutzt, ne?
57:07
Und das ist halt n riesen Painpoint, der dann echt zu also
57:10
wirklich zuschlägt, früher oder später.
57:12
Was man nicht so auf dem Schirm hat, weil ich sage in dem Punkt
57:16
sag ich ja. Ich möchte jetzt so realistisch
57:19
wie möglich an meine echte Produktivdatenbank rankommen und
57:23
gleichzeitig sagt meine Infrastruktur, die hart, die
57:26
jetzt codiert ist, ja, aber früher oder später werde ich
57:31
weglaufen, so nach dem Motto Ne und dann kann es wieder sein,
57:34
dass gewisse Sachen nicht mehr unterstützt sind.
57:36
Neu dazu gekommen sind, umgeändert sind, was du gerade
57:39
meintest und das ist halt n absolutes Learning zu sagen ne
57:44
Version auch mal. Festpinnen also wirklich sagen,
57:47
nimm diese Version, was nicht heißt, dass man so ne Version
57:51
nicht mal hochziehen sollte, aber das muss ja bewusst
57:54
passieren und nicht auf der einen Seite ja, auf der anderen
57:57
Seite nicht. Deswegen ist das auf jeden Fall
57:59
so n Ding worauf man achten sollte, meiner Meinung nach
58:02
deiner Meinung nach, falls es da andere Ansichten gibt, sagt uns
58:07
gerne Bescheid, wir lieben es über sowas zu reden und vor
58:10
allen Dingen auch Sachen zu lernen, ne DW genau.
58:15
Dann würd ich sagen, haben wir das Thema eigentlich ziemlich
58:18
ausführlich besprochen. Ich würd sagen, du kannst den
58:20
Sack noch zu machen, gib uns mal noch so ne letzte Weisheit mit.
58:25
Ja, ne letzte Weisheit. Ich sag mal so überall dort ja
58:32
wo ich sag mal du Abhängigkeiten im Code hast.
58:37
Also du irgendwelche Integrationen halt eben hast.
58:40
Ne also zum Beispiel dein Code muss.
58:43
Hat ne Abhängigkeit zu einer Datenbank oder zu einem anderen
58:46
Service. Wie auch immer, dann kannst du
58:50
halt testcontainers nehmen um halt genau dieses Problem zu
58:53
lösen, wie zum Beispiel mit den Datenbanken, was wir halt eben
58:55
gerade schon ausführlich besprochen haben hier wie
58:57
gesagt, stellvertretend für externe Services, man kennt es,
59:03
haben viele gehabt und haben teilweise immer noch diese
59:06
Probleme und. Du kannst halt schaffen, dass du
59:11
Integration Tests laufen lassen kannst mit echter Infrastruktur,
59:14
also nicht mit gemokkten Sachen, sondern mit echter
59:17
Infrastruktur, wie ich eingehends auch meinte.
59:19
Es klappt natürlich nicht immer, wenn du kein Docker Image
59:22
hochfahren kannst. Von einer Anwendung von einem
59:25
Service über das das wovon es kein Image gibt, was du nicht
59:30
nutzen kannst, dann funktioniert es natürlich nicht, dann versuch
59:32
halt möglichst nah da ranzukommen, aber ich sag mal
59:36
so, überall wo es geht sollte man das dann auch am Ende
59:38
nutzen. Um halt eben die bestmögliche,
59:42
ja Testumgebung, Infrastruktur halt eben auch zu haben.
59:46
Genau und genau dafür steht testcontainers ne, das ist halt
59:50
wirklich n Problem was es immer schon irgendwie gab und dafür
59:54
ist es auf jeden Fall ne ganz coole Lösung, da bleibt uns
59:57
eigentlich nur noch eine Frage offen und zwar an dich liebe
1:00:00
Zuhörer, liebe Zuhörer. Wie machst du denn das Ganze?
1:00:04
Testest du eher mit einer in Memory Datenbank oder sagst du
1:00:07
nee ich versuche auch nah an den echten Service ranzukommen oder
1:00:10
nutzt zum Beispiel auch Testcontainers.
1:00:13
Lass es uns gerne wissen und vor allem schreib uns auch welche
1:00:18
Lösung du da so anstrebst und umgesetzt hast.
1:00:21
Was dir Mehrwert gegeben hat, wir lieben den Austausch, kommen
1:00:24
auch gerne auf unseren Discord vorbei, Diskutier mit uns da es
1:00:28
ist eine mega coole entspannte Runde da am Link wie immer in
1:00:30
den Shownotes. Ansonsten ja, wenn dir der
1:00:35
Podcast gefällt, auch hier noch mal die Anmerkung.
1:00:38
Lass gerne ne Bewertung da, falls du es noch nicht getan
1:00:40
hast, empfiehl Ihnen weiter Leute die sich denken, Ach das
1:00:44
wär eigentlich auch n guter Podcast für mich, die müssen
1:00:47
davon natürlich erfahren und in Shownotes findest du auch n
1:00:51
spendenlink wenn du Lust hast uns zu unterstützen, dann vielen
1:00:54
vielen Dank und ansonsten hören wir uns alle nächste Woche
1:00:57
wieder, habt ne gute Zeit bis dahin ciao ciao.
1:01:01
Deine Coding Buddies gemeinsam besser Fabi, lass uns noch kurz
1:01:09
auf dein Problem vom Anfang zurückkommen.
1:01:12
Nimm einfach einen Lappen.