WEBVTT

00:00:00.000 --> 00:00:05.220
Ja, hallo liebe Hörerinnen und Hörer, willkommen beim Python Podcast, Episode 53 mit PyTest.

00:00:05.760 --> 00:00:06.160
Hi Jochen.

00:00:06.520 --> 00:00:08.020
Ja, hallo Dominik, willkommen.

00:00:08.700 --> 00:00:10.960
Ja, mein Gott, und zwar den Florian. Hey Florian.

00:00:11.240 --> 00:00:12.660
Hallo, hallo zusammen.

00:00:13.520 --> 00:00:18.920
Ja, wir haben heute Masse öfter mal was mit PyTest und da haben wir gedacht, dann fragen wir dich doch einfach mal, ob du mich was darüber erzählen magst.

00:00:19.960 --> 00:00:28.480
Genau. Ich weiß nicht, vielleicht magst du ja einfach mal so ein bisschen erzählen, was du so tust oder irgendwie, warum PyTest da ein ganz gutes Thema wäre.

00:00:30.000 --> 00:00:32.200
Was ich so tue, ist schon eine Frage, da kann ich

00:00:32.200 --> 00:00:33.560
vielleicht fünf Minuten dazu reden.

00:00:35.560 --> 00:00:38.120
Ich mache tatsächlich

00:00:38.120 --> 00:00:40.180
so fast Vollzeit

00:00:40.180 --> 00:00:40.820
Open Source

00:00:40.820 --> 00:00:44.100
und zwar kam das

00:00:44.100 --> 00:00:45.960
nicht vom PyTest ursprünglich, sondern von

00:00:45.960 --> 00:00:47.520
einem anderen Projekt von mir, von

00:00:47.520 --> 00:00:49.600
Qt Browser, kann ich gleich

00:00:49.600 --> 00:00:51.500
nochmal mehr dazu sagen.

00:00:52.740 --> 00:00:53.620
Über das Projekt bin ich

00:00:53.620 --> 00:00:54.920
danach zu PyTest gekommen

00:00:54.920 --> 00:00:57.520
und was ich jetzt eigentlich

00:00:57.520 --> 00:00:59.980
mache, ist zum einen

00:00:59.980 --> 00:01:02.080
Ich arbeite an QBrowser um PyTest

00:01:02.080 --> 00:01:03.460
durch Spenden finanziert

00:01:03.460 --> 00:01:06.180
und zum anderen gebe ich im Herbst

00:01:06.180 --> 00:01:07.700
jeweils hier an der Fachhochschule

00:01:07.700 --> 00:01:10.480
Python-Unterricht für Erstsemesterstudierende

00:01:10.480 --> 00:01:11.880
also Bachelor

00:01:11.880 --> 00:01:13.900
Informatikstudierende

00:01:13.900 --> 00:01:16.320
Also ja, ganz viel Open Source

00:01:16.320 --> 00:01:17.760
ganz viel auch

00:01:17.760 --> 00:01:20.020
Freiheit, sage ich mal, wann ich

00:01:20.020 --> 00:01:22.140
was mache und eben auch viel PyTest

00:01:22.140 --> 00:01:24.260
Ja genau, du bist einer der

00:01:24.260 --> 00:01:25.480
PyTest-Maintenner auch

00:01:25.480 --> 00:01:27.820
Genau

00:01:27.820 --> 00:01:29.840
Das hat auch ganz lustig schon angefangen

00:01:29.840 --> 00:01:32.540
Ich hab da halt eben durch

00:01:32.540 --> 00:01:34.840
Cube Browser, durch das Projekt reingekommen

00:01:34.840 --> 00:01:36.520
weil ich da Tests geschrieben hatte

00:01:36.520 --> 00:01:38.680
dafür, damals noch mit

00:01:38.680 --> 00:01:40.540
Unitest Framework von Python

00:01:40.540 --> 00:01:41.720
was mit Python mitkommt

00:01:41.720 --> 00:01:43.660
und

00:01:43.660 --> 00:01:46.580
da gab's dann so ein Adopt PyTest

00:01:46.580 --> 00:01:48.700
Month, April 15

00:01:48.700 --> 00:01:49.780
glaube ich, sowas

00:01:49.780 --> 00:01:52.720
Also doch schon

00:01:52.720 --> 00:01:53.500
eine Weile her, ja

00:01:53.500 --> 00:01:56.700
Wo dann Leute hinter

00:01:56.700 --> 00:01:58.680
PyTest, anderen Open Source

00:01:58.680 --> 00:02:01.080
Maintainern, anderen Projekten, geholfen

00:02:01.080 --> 00:02:02.520
haben, auf PyTest umzusteigen.

00:02:03.380 --> 00:02:04.660
Da habe ich eben mitgemacht mit

00:02:04.660 --> 00:02:06.760
Cube Browser und bin dann

00:02:06.760 --> 00:02:08.600
ziemlich schnell zu PyTest gekommen und

00:02:08.600 --> 00:02:10.660
habe angefangen, da Dinge zu verbessern

00:02:10.660 --> 00:02:12.800
an Plugins, Dinge zu implementieren,

00:02:13.700 --> 00:02:14.420
die ich halt

00:02:14.420 --> 00:02:16.780
haben wollte oder die mir aufgefallen

00:02:16.780 --> 00:02:18.780
sind. Und dann hieß

00:02:18.780 --> 00:02:20.480
es irgendwann, ja, willst du nicht das nächste

00:02:20.480 --> 00:02:22.520
Release machen? Und ich fand halt, ja,

00:02:22.700 --> 00:02:24.420
Moment mal, ich habe ja noch nicht mal irgendwie

00:02:24.420 --> 00:02:26.600
Commit-Rechte. Und

00:02:26.600 --> 00:02:28.540
wie es halt so läuft bei Open Source, seit da habe

00:02:28.540 --> 00:02:58.520
in der PyTest-Serie.

00:02:58.540 --> 00:03:00.180
Vielen Dank für den Einsatz

00:03:00.180 --> 00:03:02.980
War aber diesmal sehr entspanntes Update

00:03:02.980 --> 00:03:03.900
Hat alles gut funktioniert

00:03:03.900 --> 00:03:05.100
Nicht wie deprecated

00:03:05.100 --> 00:03:07.840
Was die Verbesserung angeht

00:03:07.840 --> 00:03:10.160
Es gibt ein tolles neues Ding

00:03:10.160 --> 00:03:13.200
Ein Bug, der seit 18 Jahren offen war

00:03:13.200 --> 00:03:14.580
Ein Issue, der seit 18 Jahren offen war

00:03:14.580 --> 00:03:15.320
Der jetzt geschlossen wurde

00:03:15.320 --> 00:03:18.280
Da ging es darum, dass er eigentlich blöd ist

00:03:18.280 --> 00:03:20.860
Wenn man bei einem Modelfield

00:03:20.860 --> 00:03:22.060
Default angibt

00:03:22.060 --> 00:03:24.880
Dass das nur dann ausgefüllt wird

00:03:24.880 --> 00:03:26.800
Wenn man eine Zeile

00:03:26.800 --> 00:03:28.760
über, also das Modell tatsächlich über Django

00:03:28.760 --> 00:03:30.540
baut und

00:03:30.540 --> 00:03:32.780
auch da ist es halt nicht immer so klar, dass das wirklich

00:03:32.780 --> 00:03:34.960
dann passiert, weil es gibt ja auch noch ByCreate

00:03:34.960 --> 00:03:35.800
und man kann halt auf

00:03:35.800 --> 00:03:38.800
verschlungenen Wegen irgendwie Dinge erzeugen in der Datenbank.

00:03:39.000 --> 00:03:40.580
ByCreate macht Defaults nicht rein?

00:03:41.220 --> 00:03:42.900
Nicht unbedingt. Also es kann sein,

00:03:43.020 --> 00:03:44.800
dass wenn du das jetzt einfach so verwendest, dass es dann

00:03:44.800 --> 00:03:46.340
klappt. Das war mir tatsächlich neu.

00:03:46.600 --> 00:03:48.560
Aber wenn du das halt irgendwie so ein bisschen

00:03:48.560 --> 00:03:50.680
avancierter verwendest

00:03:50.680 --> 00:03:52.080
und wirklich schnell sein willst,

00:03:52.280 --> 00:03:54.500
dann kann es gut sein, dass das nicht passiert.

00:03:54.500 --> 00:03:56.620
Und das ist natürlich doof.

00:03:56.800 --> 00:03:58.820
Das hat wahrscheinlich auch mit der Funktionalität zu tun,

00:03:58.880 --> 00:04:00.800
dass man jetzt so Felder haben kann, die von

00:04:00.800 --> 00:04:02.960
anderen Feldern abhängig sind und zwar direkt im Feld

00:04:02.960 --> 00:04:04.800
und ohne das halt über die Save-Methode zu machen.

00:04:06.940 --> 00:04:09.140
Ja, nee, das weiß ich gar nicht, ob die direkt zusammenhängen.

00:04:09.220 --> 00:04:10.200
Das geht jetzt auch, genau.

00:04:11.020 --> 00:04:12.520
Die Sarah hat einen tollen Blog-Eintrag zugeschrieben.

00:04:12.740 --> 00:04:14.900
Ja, gibt's auch ein Video, hat sie

00:04:14.900 --> 00:04:17.320
dazu gemacht. Genau, die macht ja hier auch die

00:04:17.320 --> 00:04:19.160
PyColon-Meetup-Gruppe

00:04:19.160 --> 00:04:20.760
organisiert sie mit.

00:04:21.900 --> 00:04:23.100
Ja, genau.

00:04:23.260 --> 00:04:25.000
Also, was jetzt geht, ist halt, dass man

00:04:25.000 --> 00:04:27.200
nicht sagt Default in einem Model Field,

00:04:27.320 --> 00:04:28.140
sondern DB

00:04:28.140 --> 00:04:30.460
Und dann

00:04:30.460 --> 00:04:33.080
wird das halt nicht nur gesetzt, wenn man

00:04:33.080 --> 00:04:34.620
halt irgendwie über Django das Ding

00:04:34.620 --> 00:04:37.160
baut, sondern halt in die Datenbank

00:04:37.160 --> 00:04:38.900
mit reingeschrieben, dass

00:04:38.900 --> 00:04:41.060
das so ist. Und ja, das ist ja

00:04:41.060 --> 00:04:42.940
schon mal ziemlich großartig. Man kann es halt auch jetzt

00:04:42.940 --> 00:04:44.920
sehen, welche Defaults es gibt, wenn man einfach

00:04:44.920 --> 00:04:46.920
nur sich das Schema anguckt und nicht irgendwie

00:04:46.920 --> 00:04:49.060
den Applikationscode dazu hat, was ja auch so ein Ding

00:04:49.060 --> 00:04:50.820
ist, dass es halt blöd ist, wenn man

00:04:50.820 --> 00:04:52.640
ein Datenbankschema hat, das man nur verstehen kann, wenn man

00:04:52.640 --> 00:04:54.340
den Applikationscode auch dazu legt, weil

00:04:54.340 --> 00:04:55.580
Applikationscode halt

00:04:55.580 --> 00:04:58.280
deutlich volatiler ist oft als Datenbankschema.

00:04:59.080 --> 00:05:00.460
Ja, aber also das

00:05:00.460 --> 00:05:02.100
ist jetzt ziemlich cool und genau, so

00:05:02.100 --> 00:05:04.380
viele haben, also ich habe immer verwendet

00:05:04.380 --> 00:05:06.300
sowas wie Timestamp-Model aus den Django

00:05:06.300 --> 00:05:08.200
Extensions oder halt aus Django

00:05:08.200 --> 00:05:10.380
Model Utils, um zum Beispiel

00:05:10.380 --> 00:05:11.440
sowas wie Created

00:05:11.440 --> 00:05:14.180
Zeitstempel oder Modified updated

00:05:14.180 --> 00:05:16.120
dran zu bauen. Das kann man ja jetzt halt auf eine deutlich

00:05:16.120 --> 00:05:16.940
elegantere Art machen.

00:05:19.200 --> 00:05:20.340
Generated Field heißt das glaube ich,

00:05:20.420 --> 00:05:22.380
einfach Models, Generated Field und dann...

00:05:22.380 --> 00:05:24.140
Generated Field ist jetzt die andere Geschichte,

00:05:24.140 --> 00:05:42.740
Genau, da kann man dann halt auch so Dinge, manchmal möchte man ja auch irgendwas indizieren können, was halt irgendwie, was halt auf irgendwas basiert, was halt berechnet wird aus unterschiedlichen Spalten, die man halt in der Datenbank hat und nicht direkt irgendwie eine Spalte selber ist und das geht jetzt halt auch relativ einfach.

00:05:42.740 --> 00:05:44.720
Ja, dann gab es noch

00:05:44.720 --> 00:05:47.080
ich habe jetzt aber ganz ehrlich gesagt vergessen

00:05:47.080 --> 00:05:49.200
was es genau war, es gab einige Verbesserungen

00:05:49.200 --> 00:05:50.980
an den Formularen

00:05:50.980 --> 00:05:53.160
also man kann jetzt irgendwie

00:05:53.160 --> 00:05:54.720
Help Text und

00:05:54.720 --> 00:05:56.880
Label und Dinge irgendwie

00:05:56.880 --> 00:05:59.080
einfacher benutzen, wenn man jetzt

00:05:59.080 --> 00:06:01.060
einzelne Felder als Fieldset einfach verwendet, dann sind

00:06:01.060 --> 00:06:02.280
die automatisch glaube ich mit dabei

00:06:02.280 --> 00:06:05.040
Genau, das muss man vorher mal ganz umständlich auseinander proben

00:06:05.040 --> 00:06:06.840
Ja, und ja

00:06:06.840 --> 00:06:09.500
ehrlich gesagt, mehr kann ich mich nicht erinnern

00:06:09.500 --> 00:06:11.120
Aber ja

00:06:11.120 --> 00:06:41.100
und PyTest.

00:06:41.120 --> 00:07:11.100
und PyTest.

00:07:11.120 --> 00:07:13.200
Organisation ist und

00:07:13.200 --> 00:07:15.120
die kontrolliert halt

00:07:15.120 --> 00:07:17.220
die kommerzielle Entität, die halt nur deswegen

00:07:17.220 --> 00:07:18.420
gegründet worden ist, weil

00:07:18.420 --> 00:07:21.080
man halt diese JetGPT-Geschichte auch als

00:07:21.080 --> 00:07:23.200
Produkt irgendwie rausbringen wollte und dann gesagt hat, okay, das können

00:07:23.200 --> 00:07:24.020
wir nicht im Rahmen von diesem

00:07:24.020 --> 00:07:27.080
Non-Profit machen, weil das wird einfach

00:07:27.080 --> 00:07:29.160
zu teuer und wir müssen da irgendwie

00:07:29.160 --> 00:07:31.180
auch Fremdkapital haben, um das halt

00:07:31.180 --> 00:07:32.000
irgendwie alles

00:07:32.000 --> 00:07:34.820
berechnen zu können und so und

00:07:34.820 --> 00:07:36.620
ja, im Vorfeld davon ist jetzt,

00:07:36.620 --> 00:07:38.520
der Name fällt mir nicht mehr ein, der

00:07:38.520 --> 00:07:40.860
Gründer von

00:07:40.860 --> 00:07:43.740
Anthropic, also der Firma, die jetzt auch

00:07:43.740 --> 00:07:45.200
Cloud irgendwie gebaut hat.

00:07:45.480 --> 00:07:47.900
Also ein ähnliches Ding ist wie JetGPG, bloß halt

00:07:47.900 --> 00:07:49.740
sozusagen von einer Firma.

00:07:50.260 --> 00:07:51.400
Der war vorher bei OpenAI

00:07:51.400 --> 00:07:53.220
und der hat auch schon mal versucht,

00:07:53.420 --> 00:07:54.700
Sam Oldman vom

00:07:54.700 --> 00:07:56.640
Board feuern zu lassen.

00:07:57.380 --> 00:07:59.380
Also der hat zuerst gesagt, hey, das ist nicht okay,

00:07:59.480 --> 00:07:59.980
so geht das nicht.

00:08:01.380 --> 00:08:02.880
Das könnt ihr ja so nicht machen.

00:08:03.420 --> 00:08:05.680
Und dann hat er

00:08:05.680 --> 00:08:06.820
sich ans Board gewendet und gesagt,

00:08:06.820 --> 00:08:08.920
feuert den CEO mal,

00:08:09.340 --> 00:08:10.300
das ist irgendwie nicht okay.

00:08:10.860 --> 00:08:12.540
und dann hat das Board drüber nachgedacht

00:08:12.540 --> 00:08:13.760
und dann haben sie gesagt, nee.

00:08:14.360 --> 00:08:16.340
Und dann hat er gesagt, gut, dann gehe ich jetzt halt und hat ein paar Leute

00:08:16.340 --> 00:08:17.860
mitgenommen und dann hat er eine neue Firma aufgemacht.

00:08:18.880 --> 00:08:20.460
Und ja, aber das ist jetzt noch gar nicht so

00:08:20.460 --> 00:08:22.320
lange her. Ich meine, da überschlagen sich natürlich so

00:08:22.320 --> 00:08:24.300
ein bisschen die Ereignisse irgendwie, aber das ist jetzt

00:08:24.300 --> 00:08:25.720
auch erst knapp über ein Jahr her.

00:08:26.960 --> 00:08:28.360
Und ja, offenbar...

00:08:28.360 --> 00:08:30.400
Ja, bei dem ist der Rest, die neuen Sachen sind alle ziemlich

00:08:30.400 --> 00:08:32.420
closed, wenn man so ein bisschen genauer hinguckt.

00:08:32.920 --> 00:08:34.080
Ja, das ist natürlich immer

00:08:34.080 --> 00:08:36.340
so ein bisschen, also OpenAI, ich meine, der Name

00:08:36.340 --> 00:08:37.600
ist so ein bisschen...

00:08:37.600 --> 00:08:39.600
Ja, die Propertäre

00:08:39.600 --> 00:08:40.020
und so.

00:08:41.020 --> 00:08:43.240
Ja, und natürlich ist halt auch die Frage...

00:08:43.240 --> 00:08:45.400
Die Papers sind geschlossen, da sind nur noch Zusammenfassungen drin und

00:08:45.400 --> 00:08:47.460
keine richtig guten Erkenntnisse mehr und so.

00:08:47.600 --> 00:08:49.360
Ja, ja, das sind nur noch so Technical Reports.

00:08:50.340 --> 00:08:51.160
Und natürlich, also

00:08:51.160 --> 00:08:53.720
OpenAI macht keine Open-Source-Modelle

00:08:53.720 --> 00:08:55.460
oder sowas. Die haben überhaupt nie irgendwas

00:08:55.460 --> 00:08:57.680
released. Und eigentlich

00:08:57.680 --> 00:08:59.480
ist halt die Mission von dem Non-Profit

00:08:59.480 --> 00:09:01.520
sozusagen der Allgemeinheit irgendwie

00:09:01.520 --> 00:09:03.280
zu nutzen.

00:09:04.100 --> 00:09:05.480
Ja, wäre mal

00:09:05.480 --> 00:09:07.600
schön. Und dann ist halt die Frage, wie lässt

00:09:07.600 --> 00:09:09.320
sich das vereinbaren, wenn man auf der einen Seite

00:09:09.320 --> 00:09:10.220
halt irgendwie jede Menge

00:09:10.220 --> 00:09:13.160
Risikokapital nimmt und irgendwie dann

00:09:13.160 --> 00:09:15.240
Produkte baut und dann Geld dafür einnimmt und

00:09:15.240 --> 00:09:17.160
sich im Grunde in Konkurrenz sieht mit

00:09:17.160 --> 00:09:18.160
den großen

00:09:18.160 --> 00:09:21.220
Tech-Giganten und halt auch ja von einem von

00:09:21.220 --> 00:09:22.740
denen halt ja massiv finanziert wird,

00:09:23.020 --> 00:09:25.300
Microsoft hat da irgendwie eine Milliarde

00:09:25.300 --> 00:09:26.920
reingesteckt oder so und

00:09:26.920 --> 00:09:28.880
halt auch eine Bewertung hat inzwischen von

00:09:28.880 --> 00:09:31.120
80 Milliarden oder irgendwie ganz

00:09:31.120 --> 00:09:33.020
unglaubliche Beträge und

00:09:33.020 --> 00:09:35.180
ja, und dann halt

00:09:35.180 --> 00:09:37.100
auch nichts mehr in der Richtung tut, was

00:09:37.100 --> 00:09:39.200
halt die Mission eigentlich vorgibt, dann kann ich

00:09:39.200 --> 00:10:09.180
und PyTest.

00:10:09.200 --> 00:10:12.380
und was AI Act in Europa angeht und so.

00:10:12.540 --> 00:10:13.240
Wo man ja auch sagen muss,

00:10:13.340 --> 00:10:15.180
Wir sind für ein AI.

00:10:16.160 --> 00:10:17.300
Regulierung, sagte der Minister.

00:10:17.560 --> 00:10:19.400
Nein, ich meine, Regulierung ist ja vielleicht gar nicht so schlecht,

00:10:19.520 --> 00:10:22.180
aber sozusagen die Konkurrenz von OpenAI zu regulieren,

00:10:22.240 --> 00:10:24.220
sodass man die Regulierung um Erlaubnis fragen muss,

00:10:24.280 --> 00:10:26.520
bevor man da irgendwas machen darf, ist vielleicht...

00:10:26.520 --> 00:10:27.740
Also ich bin...

00:10:27.740 --> 00:10:29.660
Das ist für mich ein ganz neues Pass.

00:10:30.540 --> 00:10:31.900
Das Pass will man vielleicht nicht aufmachen,

00:10:32.020 --> 00:10:34.500
aber dass man das regulieren will,

00:10:34.580 --> 00:10:35.760
dass Leute da nicht zu Schaden kommen,

00:10:35.820 --> 00:10:36.980
das kann ich durchaus nachvollziehen.

00:10:36.980 --> 00:10:38.140
Ja und nein.

00:10:39.200 --> 00:10:42.180
Ja, also ich finde das ist, aber das ist ja, da kann man wenig gegen sagen.

00:10:42.640 --> 00:10:44.180
Nein, also der Wunsch ist richtig, würde ich sagen.

00:10:44.380 --> 00:10:48.760
Ja, also, aber dass man jetzt die Technik selber reguliert, das finde ich halt komisch.

00:10:48.780 --> 00:10:49.080
Ja, genau.

00:10:49.340 --> 00:10:53.280
Das ist halt irgendwie, und ja, da gab es halt diverse Lobby-Stremungen.

00:10:53.280 --> 00:10:56.680
Ja, die Frage ist halt, wie das halt überhaupt geht, ohne dass man jetzt den Stecker zieht oder so.

00:10:56.840 --> 00:10:56.960
Ja.

00:10:58.240 --> 00:11:00.180
Naja, jedenfalls ist es ja jetzt auch nicht so gekommen.

00:11:00.420 --> 00:11:05.180
Es ist jetzt wie die Richtlinie, das ist ja noch nicht unter Sach und Fach.

00:11:05.180 --> 00:11:07.620
Es ist ja bloß irgendwie sozusagen, es gibt ein Verhaltungsergebnis.

00:11:07.620 --> 00:11:09.880
auch irgendwie seit letzter Woche oder sowas.

00:11:10.000 --> 00:11:12.020
Das sagt ja auch im Grunde, ja, im Wesentlichen

00:11:12.020 --> 00:11:14.120
wir regulieren halt die Anwendung,

00:11:14.240 --> 00:11:15.300
aber nicht die Technik selber.

00:11:15.660 --> 00:11:17.620
Ja, Transparenz regeln wir halt ganz gut, nach dem Motto,

00:11:17.660 --> 00:11:18.760
du musst das Modell halt irgendwie veröffentlichen.

00:11:18.760 --> 00:11:21.880
Ja, Open Source ist halt explizit ausgenommen. Das ist halt schon mal großartig.

00:11:22.960 --> 00:11:23.680
Was halt bedeutet,

00:11:23.780 --> 00:11:25.520
okay, wenn ich jetzt hingehen will und sage,

00:11:25.680 --> 00:11:27.820
okay, ich mache hier meine eigene

00:11:27.820 --> 00:11:30.000
Suchmaschine oder so auf internen Dokumenten,

00:11:30.140 --> 00:11:31.640
die halt irgendwie besser funktionieren soll,

00:11:32.120 --> 00:11:33.920
dann muss ich nicht OpenAI

00:11:33.920 --> 00:11:35.700
fragen, sondern dann kann ich das halt irgendwie

00:11:35.700 --> 00:12:05.680
und PyTest.

00:12:05.700 --> 00:12:06.860
überhaupt gar keine Gefahr.

00:12:07.100 --> 00:12:08.940
Das ist, glaube ich, kein Problem für die.

00:12:08.940 --> 00:12:11.480
Nein, niemals. Warum sollte denn niemals

00:12:11.480 --> 00:12:12.800
sich jemand gruppieren lassen?

00:12:13.160 --> 00:12:14.460
Ja, also, nee, nee.

00:12:15.540 --> 00:12:15.720
Ja.

00:12:17.860 --> 00:12:19.800
Und ich meine, das Board hat ja schon gezeigt,

00:12:19.880 --> 00:12:21.480
dass sie da absolut in der Lage sind,

00:12:21.660 --> 00:12:23.520
das zu kontrollieren und durchzusetzen, wenn sie

00:12:23.520 --> 00:12:24.820
finden, dass das nicht okay ist.

00:12:28.320 --> 00:12:29.660
Daher, ich habe da überhaupt gar keine

00:12:29.660 --> 00:12:31.360
Bedingungen. Ja, okay.

00:12:31.360 --> 00:12:33.600
Also, das war sozusagen die leichte Unterhaltung.

00:12:33.620 --> 00:12:34.940
Ja, das war die leichte Unterhaltung zum Thema.

00:12:34.940 --> 00:12:37.080
kurz vor Weihnachten nochmal ein bisschen Advent.

00:12:37.600 --> 00:12:37.880
Ja.

00:12:39.520 --> 00:12:41.140
Advent of God, dann was kann man auch wieder spielen?

00:12:43.000 --> 00:12:43.400
Ja,

00:12:43.620 --> 00:12:44.560
genau, was hat man noch so?

00:12:45.700 --> 00:12:47.020
News. Ja, oh, ich...

00:12:47.020 --> 00:12:49.060
Du hast noch eine wichtige News für Python.

00:12:49.360 --> 00:12:50.520
Für Python, ja.

00:12:51.480 --> 00:12:52.480
Ja, genau,

00:12:52.760 --> 00:12:54.340
Kill Removal ist beschlossene Sache.

00:12:55.180 --> 00:12:56.920
Wer sich dafür interessiert, es gibt da einen schönen, es gibt

00:12:56.920 --> 00:12:59.080
einen neuen Podcast, weiß auch nicht, ob wir den schon

00:12:59.080 --> 00:13:01.120
erwähnt hatten, CorpyY heißt der,

00:13:01.320 --> 00:13:01.980
ist irgendwie von

00:13:01.980 --> 00:13:04.240
Lukas Langer und, na,

00:13:04.240 --> 00:13:05.840
Pablo

00:13:05.840 --> 00:13:07.260
Galindo Salgado

00:13:07.260 --> 00:13:10.020
den Release-Manager

00:13:10.020 --> 00:13:12.040
für die letzten beiden Versionen

00:13:12.040 --> 00:13:13.600
die

00:13:13.600 --> 00:13:15.760
machen den und

00:13:15.760 --> 00:13:16.800
reden halt über so

00:13:16.800 --> 00:13:19.540
C-Python-interner Geschichten

00:13:19.540 --> 00:13:21.520
zum Beispiel war das die erste Episode

00:13:21.520 --> 00:13:22.020
war über den

00:13:22.020 --> 00:13:24.880
C-Python-Core-Dev-Sprint

00:13:24.880 --> 00:13:27.120
oder halt andere Themen wie zum Beispiel

00:13:27.120 --> 00:13:29.820
dass es dann einen Just-in-Time-Compiler

00:13:29.820 --> 00:13:31.340
irgendwie für 3.13

00:13:31.340 --> 00:13:33.240
wohl geben soll und solche Dinge

00:13:33.240 --> 00:13:35.180
und da gab es jetzt auch eine Episode

00:13:35.180 --> 00:13:37.180
über das Entfernen

00:13:37.180 --> 00:13:38.920
von Gil, was halt eine komplizierte

00:13:38.920 --> 00:13:40.740
Geschichte ist und viel Arbeit wird, aber

00:13:40.740 --> 00:13:42.940
ja, jetzt wird das Ganze wohl angegangen und

00:13:42.940 --> 00:13:44.880
bin gespannt.

00:13:45.920 --> 00:13:47.140
Ich fand halt die

00:13:47.140 --> 00:13:48.980
Tagline ganz lustig vom Podcast.

00:13:50.040 --> 00:13:51.320
One talks like a

00:13:51.320 --> 00:13:52.960
Mexican, the other like a Russian.

00:13:53.260 --> 00:13:54.460
Both hate the comparison.

00:13:55.460 --> 00:13:56.960
Das hat mir gar nicht aufgefallen, aber ja, stimmt,

00:13:57.060 --> 00:13:57.340
das ist gut.

00:14:01.240 --> 00:14:03.180
Weil Cinder X, das ist die letzte Folge,

00:14:03.240 --> 00:14:06.100
Die letzte habe ich glaube ich noch nicht gehört

00:14:06.100 --> 00:14:07.460
Da haben sie

00:14:07.460 --> 00:14:10.200
da haben sie mit Karl Mayer geredet

00:14:10.200 --> 00:14:12.300
Karl Mayer, ganz interessanter

00:14:12.300 --> 00:14:13.060
Typ von Meta

00:14:13.060 --> 00:14:16.060
Ja genau, der hat, ja Meta, aber der ist

00:14:16.060 --> 00:14:18.380
einer der Hauptentwickler hinter dem

00:14:18.380 --> 00:14:19.440
Django Python

00:14:19.440 --> 00:14:21.900
Kern von Instagram

00:14:21.900 --> 00:14:24.260
Und der hat, da gab es

00:14:24.260 --> 00:14:25.820
mal eine sehr interessante Episode, ich

00:14:25.820 --> 00:14:27.720
habe jetzt wieder vergessen wo und wann, aber

00:14:27.720 --> 00:14:30.020
worüber er geredet hat, was man so

00:14:30.020 --> 00:14:32.320
Probleme kriegt, wenn man halt irgendwie mehr als

00:14:32.320 --> 00:14:34.960
deutlich mehr als eine Million Zeilen Python irgendwie hat

00:14:34.960 --> 00:14:37.080
und dann eine

00:14:37.080 --> 00:14:38.380
Anwendung, die darauf basiert.

00:14:38.660 --> 00:14:40.660
Ich glaube, den Artikel hatten wir auch schon das eine oder andere Mal

00:14:40.660 --> 00:14:42.300
irgendwo in den Turnus gelinkt, wenn ich mich recht erinnere.

00:14:42.680 --> 00:14:43.400
Kann sein, ja.

00:14:44.340 --> 00:14:45.500
Also genau, das kann man...

00:14:45.500 --> 00:14:47.640
Ja, Kopf, EY, das ist ein guter Podcast.

00:14:49.340 --> 00:14:50.960
Ja, genau.

00:14:51.140 --> 00:14:52.600
Und dann erinnere ich mich noch,

00:14:52.680 --> 00:14:54.580
letztes Jahr hatten wir

00:14:54.580 --> 00:14:55.980
darüber geredet,

00:14:56.380 --> 00:14:58.020
dass es da so gewisse Sicherheitsschwankungen

00:14:58.020 --> 00:14:59.140
bei LastPass gab.

00:14:59.860 --> 00:15:01.880
Und da dachte ich, okay, muss ich diesmal auch...

00:15:01.880 --> 00:15:03.480
Ich kann mich an den Januar und den Februar erinnern, wo ich

00:15:03.480 --> 00:15:05.280
1000 Passwörter umstellen musste, das war super

00:15:05.280 --> 00:15:07.800
Wo ich dann gesagt habe, ja, okay

00:15:07.800 --> 00:15:09.900
so prinzipiell ist One Password

00:15:09.900 --> 00:15:11.220
jetzt auch nicht so viel besser zum Beispiel

00:15:11.220 --> 00:15:14.020
aber zum Glück

00:15:14.020 --> 00:15:15.660
sind sie noch nicht irgendwie hops genommen worden

00:15:15.660 --> 00:15:18.120
Ja, da hat sich jetzt geändert, ist One Password

00:15:18.120 --> 00:15:19.900
hops genommen worden und zwar

00:15:19.900 --> 00:15:21.940
über Okta, also ich immer denke so, okay

00:15:21.940 --> 00:15:24.020
Okta ist auch so ein, ich verstehe nicht genau

00:15:24.020 --> 00:15:25.720
warum Unternehmen sowas verwenden, aber okay

00:15:25.720 --> 00:15:27.880
Ja, ist ja total super, SSO und so

00:15:27.880 --> 00:15:29.680
muss man alles über so ein Anbieter machen

00:15:29.680 --> 00:15:31.760
Ist Okta nicht auch hinter ZeroAuth?

00:15:31.880 --> 00:15:33.820
Ja, auch Zero, ja.

00:15:35.200 --> 00:15:35.600
Ja,

00:15:35.800 --> 00:15:39.460
also ich glaube, es war nicht so ganz

00:15:39.460 --> 00:15:40.680
super schlimm, aber

00:15:40.680 --> 00:15:43.520
dazu gab es auch ein Postmortem,

00:15:43.600 --> 00:15:45.580
was wir veröffentlicht haben und das war einfach nur, wenn man sich das anguckt,

00:15:45.660 --> 00:15:46.620
das war einfach nur total schrecklich.

00:15:47.720 --> 00:15:49.480
Oh ja, wir versprechen euch, es ist

00:15:49.480 --> 00:15:51.460
gar nichts geleakt worden und es ist auch nichts

00:15:51.460 --> 00:15:53.600
kaputt gegangen. Es sind jetzt so ein paar Dokumente

00:15:53.600 --> 00:15:54.260
verloren gegangen.

00:15:56.400 --> 00:15:57.540
Zugriff auf die Datenbank

00:15:57.540 --> 00:15:58.000
oder sowas.

00:15:59.960 --> 00:16:01.520
Ja, ich habe auch keine gute Lösung dafür.

00:16:01.520 --> 00:16:03.300
Ich weiß nicht, wenn es das...

00:16:03.300 --> 00:16:05.760
Ich finde es schwierig tatsächlich. Wir hatten ja letztes Jahr

00:16:05.760 --> 00:16:07.440
schon mal das Thema. Ja, das Thema hatten wir schon mal.

00:16:07.580 --> 00:16:09.920
Es kommt irgendwie immer wieder. Verrätst du, wie du das machst,

00:16:10.020 --> 00:16:11.460
Florian? Passwörter?

00:16:12.420 --> 00:16:13.480
Ja, tatsächlich

00:16:13.480 --> 00:16:15.280
ganz langweilig lokal bisher.

00:16:15.760 --> 00:16:17.860
Mit keypass.xc

00:16:17.860 --> 00:16:19.720
ist es glaube ich inzwischen.

00:16:19.920 --> 00:16:21.440
Ich bin da mal irgendwie gewechselt

00:16:21.440 --> 00:16:22.780
von einem Volk zum anderen.

00:16:23.920 --> 00:16:25.680
Das und dann so ein

00:16:25.680 --> 00:16:27.380
minimales Frontend darüber

00:16:27.380 --> 00:16:29.720
namens keepMenu, was dann auf

00:16:29.720 --> 00:16:31.800
Rofi aufsetzt, also so ein

00:16:31.800 --> 00:16:33.440
Keyboard-Menü.

00:16:35.840 --> 00:16:37.480
Und dann, ja, wenn ich mal irgendwie

00:16:37.480 --> 00:16:39.520
was brauche, was

00:16:39.520 --> 00:16:41.860
editieren muss oder so, mache ich halt dieses Keypass-XC

00:16:41.860 --> 00:16:44.240
auf und sonst einfach alles mit Tastaturkürzel

00:16:44.240 --> 00:16:45.400
und Autotype.

00:16:45.800 --> 00:16:47.560
Aber du kommst halt auch von dem Rechner nicht runter, ne?

00:16:47.560 --> 00:16:49.840
Und wenn der Rechner irgendwie dein Backup-Problem

00:16:49.840 --> 00:16:51.400
hat, dann ist es blöd.

00:16:52.480 --> 00:16:53.560
Das ist so, ja.

00:16:53.700 --> 00:16:55.520
Ich habe tatsächlich dann teilweise das Problem,

00:16:55.640 --> 00:16:57.320
dass ich halt irgendwo am Handy mal

00:16:57.320 --> 00:16:58.960
irgendwo ein Passwort brauche oder so.

00:16:59.720 --> 00:17:01.940
Aber ich bin eh so der Mensch, der fast immer

00:17:01.940 --> 00:17:03.040
sein Laptop dabei hat

00:17:03.040 --> 00:17:05.940
Zum einen, und was Backups angeht

00:17:05.940 --> 00:17:07.980
habe ich das tatsächlich dann alles mal ausgedrückt

00:17:07.980 --> 00:17:10.280
und in ein Bankschließfach

00:17:10.280 --> 00:17:11.440
gelegt

00:17:11.440 --> 00:17:13.540
Das ist keine so schlechte Idee

00:17:13.540 --> 00:17:15.420
Weil ich halt doch fand

00:17:15.420 --> 00:17:17.940
wenn das weg ist, habe ich echt ein gröberes Problem

00:17:18.580 --> 00:17:21.480
Ja, also ich finde auch

00:17:21.480 --> 00:17:22.680
für mich alleine oder so, da bin ich auch

00:17:22.680 --> 00:17:25.840
das sah schon gut aus

00:17:25.840 --> 00:17:27.580
aber das Problem für mich ist halt auch

00:17:27.580 --> 00:17:29.480
der Support von irgendwie so

00:17:29.480 --> 00:17:31.460
Familie und Verwandten

00:17:31.460 --> 00:17:33.740
und das und Sharing und mal irgendwie

00:17:33.740 --> 00:17:34.960
für jemanden was freischalten und so.

00:17:35.660 --> 00:17:37.600
Und da habe ich bisher noch keine

00:17:37.600 --> 00:17:39.360
gute Geschichte gefunden. Ja, ich finde also

00:17:39.360 --> 00:17:41.060
2FA tatsächlich gar nicht so schlecht.

00:17:41.480 --> 00:17:43.740
Und dann halt immer irgendwie so ein Key mitnehmen,

00:17:44.040 --> 00:17:45.840
wo ich halt auch, dann gibt es halt nur Timer oder so was

00:17:45.840 --> 00:17:46.960
und einer ist dann halt im Bankschließfach

00:17:46.960 --> 00:17:48.520
und den brauchst du halt dann.

00:17:49.200 --> 00:17:50.960
Das ist auch keine schlechte Idee, finde ich.

00:17:52.360 --> 00:17:53.740
Ja, also was ich mir

00:17:53.740 --> 00:17:55.680
wahrscheinlich anschauen würde, wenn ich

00:17:55.680 --> 00:17:57.240
jetzt was will, was ein bisschen mehr

00:17:57.240 --> 00:17:58.880
Clouds dran hat, sage ich mal,

00:17:58.880 --> 00:18:01.020
Spitwarden.

00:18:01.740 --> 00:18:02.920
Weil das ist, glaube ich,

00:18:03.360 --> 00:18:05.480
größtenteils Open Source und es gibt, glaube ich,

00:18:05.500 --> 00:18:07.880
auch eine alternative Server-Implementation,

00:18:08.180 --> 00:18:09.680
die man dann irgendwie selber hosten kann.

00:18:09.940 --> 00:18:11.600
Ja, also ich habe es mir angeguckt,

00:18:11.700 --> 00:18:13.560
ich wollte auch erst alles umstellen, ich habe damit angefangen

00:18:13.560 --> 00:18:14.420
und ich weiß nicht.

00:18:15.220 --> 00:18:17.560
Also ich bin so ein Usability, ich möchte das immer

00:18:17.560 --> 00:18:19.680
einfach und schnell und so haben und irgendwie nervt es mich.

00:18:19.860 --> 00:18:21.600
Kann sein, dass das technisch die sauberste

00:18:21.600 --> 00:18:23.620
Lösung ist, aber ich fand es

00:18:23.620 --> 00:18:25.140
irgendwie total anstrengend.

00:18:26.120 --> 00:18:26.280
Ja.

00:18:26.280 --> 00:18:28.320
Naja. Ja, okay. Also vielleicht

00:18:28.320 --> 00:18:29.800
müssen wir einfach nächstes Jahr nochmal drüber reden.

00:18:30.060 --> 00:18:31.200
Ja, vielleicht ist irgendwas.

00:18:31.940 --> 00:18:34.340
Mir fällt aber auch nichts ein, was man irgendwie so architektonisch hat.

00:18:34.460 --> 00:18:35.760
Irgendeinen Tod muss man immer sterben.

00:18:36.400 --> 00:18:37.680
Also zum Beispiel, wie teile ich auch,

00:18:37.780 --> 00:18:39.620
hatten wir ja auch letztes Mal, glaube ich,

00:18:40.000 --> 00:18:42.200
Geheimnisse durch Entwicklungsteams.

00:18:43.420 --> 00:18:44.340
Auch nicht so einfach.

00:18:44.500 --> 00:18:44.660
Ja.

00:18:46.420 --> 00:18:48.360
Also ich benutze jetzt tatsächlich so einen Service,

00:18:49.880 --> 00:18:50.560
wo halt

00:18:50.560 --> 00:18:52.320
die Entwickler gar nicht mehr die Geheimnisse kennen müssen,

00:18:53.200 --> 00:18:54.480
die halt autogeneriert werden.

00:18:54.480 --> 00:18:56.900
Das heißt, ich kenne die selber nicht, aber man muss sich halt mit der API dahin verbinden

00:18:56.900 --> 00:18:58.100
und dieser Service kennt die halt alle

00:18:58.100 --> 00:18:59.120
Also, ne?

00:19:00.220 --> 00:19:02.720
Ist halt auch dann wieder irgendeine Party, die da halt Zugriff drauf hat

00:19:02.720 --> 00:19:04.300
Aber gut, dass das nichts Kritisches und so

00:19:04.300 --> 00:19:05.320
Ja, gut

00:19:05.320 --> 00:19:08.780
Aber immerhin läuft der Rest dann so

00:19:08.780 --> 00:19:09.660
Naja

00:19:09.660 --> 00:19:12.580
Das ist schwierig. Okay, ja, ich weiß nicht, ansonsten habe ich jetzt keine

00:19:12.580 --> 00:19:13.580
News mehr, glaube ich

00:19:13.580 --> 00:19:15.520
Vielleicht bräuchte man einfach ordentliche Tests für diese

00:19:15.520 --> 00:19:17.520
wundervollen Taskforce-Manager

00:19:17.520 --> 00:19:19.100
Tja

00:19:19.100 --> 00:19:21.700
Ja, also

00:19:21.700 --> 00:19:23.580
Die Überleitung war jetzt ein bisschen arglich

00:19:23.580 --> 00:19:27.120
Vielleicht reden wir ja über das Thema, dann haben wir heute nach News fertig.

00:19:27.220 --> 00:19:32.880
Ja, genau. Und dann können wir eigentlich mal hier mit PyTest starten.

00:19:33.060 --> 00:19:39.500
Ja, ich glaube, die meisten Menschen wissen, was PyTest ist, also das Testframework, was man oft benutzt, wenn man Tests in Python schreiben möchte.

00:19:40.120 --> 00:19:41.500
Würde ich auch empfehlen, ehrlicherweise.

00:19:42.620 --> 00:19:43.240
Ihr wahrscheinlich auch.

00:19:43.240 --> 00:19:43.420
Ich auch.

00:19:45.520 --> 00:19:47.840
Alleinig. Keine Überraschung soweit.

00:19:47.840 --> 00:19:52.820
Aber dann überlasse ich einfach mal dem Florian vielleicht das Wort und den Einstieg in das Thema.

00:19:53.580 --> 00:19:56.100
Das erzählst du ja vielleicht auch öfter

00:19:56.100 --> 00:19:58.480
Also ich fand auf jeden Fall den Vortrag

00:19:58.480 --> 00:20:00.860
den auf der Destiny Repricen darüber gehalten, das ist schon ziemlich gut

00:20:00.860 --> 00:20:02.340
Der war spannend

00:20:02.340 --> 00:20:02.820
Ja

00:20:02.820 --> 00:20:06.420
Erzähl ich tatsächlich öfter, weil ich ja auch

00:20:06.420 --> 00:20:08.040
Firmenkurse mache zu PyTest

00:20:08.040 --> 00:20:10.440
Das wären so die Einzelfirmaschinen

00:20:10.440 --> 00:20:12.800
die ich eben neben den OpenSource Dingen noch fahre

00:20:12.800 --> 00:20:14.500
Und

00:20:14.500 --> 00:20:16.640
da mache ich halt auch erstmal ein bisschen Werbung

00:20:16.640 --> 00:20:17.460
für PyTest

00:20:17.460 --> 00:20:20.600
Gerade früher war das vielleicht noch ein bisschen wichtiger

00:20:20.600 --> 00:20:22.520
weil da gab es oft echt noch

00:20:22.520 --> 00:20:25.880
Firmen, die umgestiegen sind von Unitest oder von Nose,

00:20:26.340 --> 00:20:27.680
ein anderes Testframework.

00:20:28.880 --> 00:20:33.000
Inzwischen muss man sagen, dass wirklich so das Default eigentlich PyTest ist.

00:20:33.140 --> 00:20:34.680
Also Nose-Test ist sogar deprecated, oder?

00:20:35.780 --> 00:20:36.500
Ne, ne.

00:20:36.880 --> 00:20:38.300
Ah, Nose-Test.

00:20:38.400 --> 00:20:39.060
Ja, Nose-Test.

00:20:39.760 --> 00:20:40.620
Da habe ich mich falsch verstanden.

00:20:41.420 --> 00:20:44.160
Da stand schon seit Jahren, steht in der Dokumentation,

00:20:44.240 --> 00:20:46.320
man soll bitte kein Nose verwenden.

00:20:47.060 --> 00:20:50.380
Es gibt irgendwie ein Nose 2, aber ich habe noch kein Projekt gefunden,

00:20:50.380 --> 00:20:51.700
was das nutzt effektiv.

00:20:52.520 --> 00:20:54.560
und wenn man sich halt dann so

00:20:54.560 --> 00:20:56.880
anschaut, wie die Userzahlen

00:20:56.880 --> 00:20:59.080
so ausschauen, es gibt ja, weiß ich ehrlich,

00:20:59.400 --> 00:21:00.600
so eine Umfrage, die

00:21:00.600 --> 00:21:02.180
Python Developer Survey

00:21:02.180 --> 00:21:05.040
von der Python Software Foundation

00:21:05.040 --> 00:21:05.980
und JetBrains

00:21:05.980 --> 00:21:09.160
und da hat PyTest

00:21:09.160 --> 00:21:10.820
ich glaube vorletztes Jahr

00:21:10.820 --> 00:21:12.880
oder so die 50% Marke

00:21:12.880 --> 00:21:14.440
geknackt.

00:21:14.500 --> 00:21:16.380
Oh ja, ich hätte sogar mehr

00:21:16.380 --> 00:21:17.240
gesagt, ehrlicherweise.

00:21:18.120 --> 00:21:20.500
Ja, wobei irgendwie 30% halt sagen,

00:21:20.500 --> 00:21:22.240
sie nutzen gar kein Testframework.

00:21:22.520 --> 00:21:23.280
Okay.

00:21:24.320 --> 00:21:24.960
Ja.

00:21:26.760 --> 00:21:28.460
Also würdet ihr denn Tests benutzen oder wann

00:21:28.460 --> 00:21:30.540
würdet ihr denn Tests benutzen? Das ist vielleicht auch eine spannende

00:21:30.540 --> 00:21:31.840
Frage oder wofür. Alles

00:21:31.840 --> 00:21:33.980
100% Covered.

00:21:34.400 --> 00:21:36.200
Jeder Commit, der die Coverage

00:21:36.200 --> 00:21:38.200
reduziert, wird automatisch nicht durch

00:21:38.200 --> 00:21:39.480
Commit durchgelassen oder

00:21:39.480 --> 00:21:42.240
gibt es da unterschiedliche Ansichten?

00:21:43.380 --> 00:21:44.400
Ich habe tatsächlich

00:21:44.400 --> 00:21:46.280
ein Projekt jetzt, wo ich das versuche.

00:21:47.880 --> 00:21:48.480
Für

00:21:48.480 --> 00:21:50.300
das Modul, was ich eben an der Fachhochschule

00:21:50.300 --> 00:21:52.040
unterrichte, da habe ich

00:21:52.040 --> 00:22:10.440
und ich habe dann eben halt auch meine Arbeit hinter dem Modul so ein bisschen automatisiert, zumindest so der langweilige Teil, also irgendwie Noten dann ausrechnen und E-Mails verschicken mit der Notenabschlüsselung und sowas.

00:22:10.440 --> 00:22:20.560
und da bin ich jetzt dran, das alles ein bisschen zu refacturen und für den neuen Teil quasi, was refactured ist, auch wirklich 100% Testcoverage zu haben.

00:22:21.280 --> 00:22:28.780
Weil ich halt finde, ja, ich berechne da irgendwie Zeugnisnoten und so, das muss halt schon irgendwie keine Box haben, idealerweise.

00:22:28.780 --> 00:22:32.700
Also ich finde auch, so kritische Teile der Infrastruktur sind ganz gut, wenn man sie testet.

00:22:32.820 --> 00:22:38.140
Also sowas wie Authentifizierung, Autorisierung oder sowas, sollte man schon irgendwo mal gucken, dass das stimmt.

00:22:38.140 --> 00:22:40.200
und die kritische Business-Logik.

00:22:41.140 --> 00:22:42.120
Also jede

00:22:42.120 --> 00:22:44.480
Einzeiler-Funktion, weiß ich jetzt nicht.

00:22:45.240 --> 00:22:46.180
Ja, es gibt ja Leute,

00:22:46.400 --> 00:22:48.040
die diesen Standpunkt vertreten und sagen,

00:22:48.140 --> 00:22:49.840
naja gut, wenn man anfängt, über solche

00:22:49.840 --> 00:22:52.180
Zahlen zu diskutieren, dann macht das eigentlich nur

00:22:52.180 --> 00:22:52.800
100% Sinn.

00:22:54.020 --> 00:22:56.260
Aber ich weiß auch nicht, ob das jetzt optimal ist

00:22:56.260 --> 00:22:58.080
für alle. Also ich habe es

00:22:58.080 --> 00:23:00.200
für ein Projekt auch gemacht, weil einfach

00:23:00.200 --> 00:23:01.280
ich das mal machen wollte.

00:23:02.640 --> 00:23:04.420
Ob das jetzt nötig

00:23:04.420 --> 00:23:05.260
wäre, weiß ich nicht.

00:23:06.320 --> 00:23:07.660
Ja, es wird schon anstrengend.

00:23:08.140 --> 00:23:10.320
Wenn man dann externe Komponenten drin hat,

00:23:11.520 --> 00:23:13.960
oder eine GUI-Applikation schreibt,

00:23:14.280 --> 00:23:15.840
dann wird es schon schwierig irgendwann.

00:23:16.160 --> 00:23:18.360
Ja genau, also welche Enden muss man dann da testen?

00:23:18.760 --> 00:23:20.300
Also ich finde ja tatsächlich auch,

00:23:20.680 --> 00:23:22.640
vielleicht jetzt direkt an dem Zeitpunkt,

00:23:22.720 --> 00:23:23.620
TDD ganz interessant,

00:23:23.760 --> 00:23:25.480
also dass man mit den Tests anfängt, die zu schreiben.

00:23:25.980 --> 00:23:27.120
Es ist nicht immer ganz einfach,

00:23:27.480 --> 00:23:28.920
weil man muss dann schon relativ genau wissen,

00:23:28.960 --> 00:23:29.640
was man machen will.

00:23:29.900 --> 00:23:30.980
Und wenn man das nicht weiß,

00:23:31.120 --> 00:23:32.080
dann braucht man halt Tests,

00:23:32.160 --> 00:23:33.200
die man hinterher wieder wegschmeißen kann,

00:23:33.300 --> 00:23:35.320
was die doppelt und dreifache Arbeit macht.

00:23:35.900 --> 00:23:37.600
Aber wenn man halt irgendwie schon

00:23:37.600 --> 00:23:39.420
ein gutes Konzept hat, dann erst Tester für zu schreiben,

00:23:39.520 --> 00:23:41.940
wie das aussehen sollte und dann die Implementierung.

00:23:42.040 --> 00:23:43.460
Das führt halt dazu, dass die dann auch tatsächlich

00:23:43.460 --> 00:23:44.120
funktioniert, ja?

00:23:45.240 --> 00:23:47.580
Wenn man sich so Gedanken dazu gemacht hat, wo so die Haken

00:23:47.580 --> 00:23:49.520
und Stellen sind, die ineinander greifen sollen.

00:23:51.020 --> 00:23:51.180
Ja.

00:23:52.500 --> 00:23:53.760
Macht ihr das auch mal?

00:23:53.880 --> 00:23:54.140
Manchmal?

00:23:55.340 --> 00:23:57.160
Ich mache es ganz gerne bei Box.

00:23:57.840 --> 00:23:59.380
Wenn ich halt irgendwann ein Bug-Report kriege,

00:23:59.440 --> 00:24:00.940
dass ich erstmal einen Test dafür schreibe.

00:24:01.800 --> 00:24:03.400
Zumindest so ab dem Punkt, wo ich das

00:24:03.400 --> 00:24:05.160
einmal manuell reproduziert habe.

00:24:05.160 --> 00:24:13.820
weil wenn ich den Bug fixe, werde ich das eh schon ein paar Mal reproduzieren müssen und dann mache ich mir halt effektiv das Leben leichter.

00:24:13.940 --> 00:24:16.800
Genau, also ich würde auch sagen, fix ist immer ein Test.

00:24:18.480 --> 00:24:25.800
Genau, so bei einer Library kann ich es mir auch noch vorstellen und wenn es dann eher Richtung Applikation geht, finde ich, wird es schon schwieriger.

00:24:25.800 --> 00:24:41.458
Also gerade jetzt wieder bei einer GUI da muss ich das Feature irgendwie erstmal implementieren und erstmal sehen wie das aussieht aus User aus Code auch bevor ich da irgendwie sinnvoll Tests daf schreiben kann finde ich Klingt sehr vern w ich

00:24:41.458 --> 00:24:42.918
ganz genauso sehen.

00:24:42.998 --> 00:24:44.118
Also ich mache auch TDD manchmal,

00:24:44.898 --> 00:24:46.458
aber gerade eben

00:24:46.458 --> 00:24:49.138
auch so bei Web-Applikationen

00:24:49.138 --> 00:24:50.798
entwickle ich oft, also oft ist es ja so,

00:24:50.818 --> 00:24:52.678
man fängt mit irgendwas an oder mir geht das halt so

00:24:52.678 --> 00:24:54.798
und dann denkt man sich irgendwann, ah nee, das ist einfach

00:24:54.798 --> 00:24:56.638
keine gute Idee und ich mache das

00:24:56.638 --> 00:24:58.458
oft in Notebooks am Anfang.

00:24:59.738 --> 00:25:00.618
Einfach nur, um zu sehen,

00:25:00.618 --> 00:25:02.798
ob irgendwas geht oder elegant geht und wenn es dann nicht geht

00:25:02.798 --> 00:25:04.198
dann sage ich so, okay, pff, ne

00:25:04.198 --> 00:25:05.898
dann mache ich doch lieber was anderes

00:25:05.898 --> 00:25:08.778
und wenn man da zuerst

00:25:08.778 --> 00:25:10.738
die Tests schreibt, dann schmeißt man die Tests ja mit weg

00:25:10.738 --> 00:25:12.578
das macht ja irgendwie, ich habe dann mal

00:25:12.578 --> 00:25:14.698
es gab auf Twitter irgendwie ein Thread, wo

00:25:14.698 --> 00:25:16.138
dann, weiß ich nicht

00:25:16.138 --> 00:25:18.338
Harry Percival, der auch dieses

00:25:18.338 --> 00:25:19.998
Obey the Testing Goat

00:25:19.998 --> 00:25:22.878
Testbuch geschrieben hat für Python

00:25:22.878 --> 00:25:24.798
und irgendwie meinte, dass Leute noch bitte

00:25:24.798 --> 00:25:26.638
mal TDD verwenden sollen und sich mal

00:25:26.638 --> 00:25:28.878
im Riemen leisten sollen, dann werde ich so, ja, ich mache das mal

00:25:28.878 --> 00:25:32.778
so. Ich weiß nicht, ich habe so das Gefühl, wenn ich zuerst Testschreiben mache, dann ist das eine totale Verschwendung,

00:25:32.878 --> 00:25:36.538
weil man ist dann oft Sachen wieder weg. Warum sollte ich da Testschreiben

00:25:36.538 --> 00:25:39.998
nicht wieder? Nee, nee, das ist ein Spike, das ist auch TDD, das ist schon okay.

00:25:40.398 --> 00:25:44.738
Na gut. Ja, aber oft muss man erstmal sehen, ob irgendwas

00:25:44.738 --> 00:25:48.978
so funktioniert, wie man denkt. Wenn man zum Beispiel die Modelle jetzt noch nicht hat von so einem Problem,

00:25:49.118 --> 00:25:52.758
oder die man definieren muss. Manchmal muss man ja irgendwie Fixes schreiben dann erstmal, um zu

00:25:52.758 --> 00:25:56.638
gucken, was denn überhaupt an Datenmodellen, wie die aussehen sollen und so. Oft lasse ich die Modelle

00:25:56.638 --> 00:25:58.538
weg und schreibt gar keine Modelle,

00:25:58.718 --> 00:26:00.038
sondern ich schreibe erstmal so,

00:26:00.478 --> 00:26:02.678
um zu sehen, ob das in der UI funktioniert.

00:26:03.578 --> 00:26:04.838
Das wäre dann Integration-Test?

00:26:05.358 --> 00:26:06.758
Nö, ich schreibe da gar keine.

00:26:06.898 --> 00:26:08.638
Wie gesagt, an der Stelle kann man noch nicht so gut Text

00:26:08.638 --> 00:26:10.538
schreiben. Wenn ich mit Test anfangen würde,

00:26:10.598 --> 00:26:12.738
würde ich ja mit den Tests vielleicht für das Modell anfangen oder so.

00:26:12.798 --> 00:26:14.458
Aber wenn ich kein Modell habe, ist es halt ein bisschen...

00:26:14.458 --> 00:26:14.758
Ja, okay.

00:26:16.258 --> 00:26:18.678
Ich will noch kurz nochmal beim Testing-Goat

00:26:18.678 --> 00:26:19.298
anklicken.

00:26:20.238 --> 00:26:22.378
Da hat jemand letztens ganz einen lustigen

00:26:22.378 --> 00:26:24.618
Thread aufgemacht, wo er fand, ja, er hat mal

00:26:24.618 --> 00:26:26.378
Chat-GPT gefragt, wo das

00:26:26.378 --> 00:26:27.858
PyTest-Logo herkommt.

00:26:28.918 --> 00:26:30.378
Und Chat-TPT meinte dann, ja,

00:26:30.438 --> 00:26:31.478
ich hätte das designt.

00:26:32.598 --> 00:26:33.598
Ist Quatsch.

00:26:34.158 --> 00:26:35.298
Ist völliger Quatsch.

00:26:35.898 --> 00:26:37.978
Das Logo gibt es nämlich schon irgendwie seit

00:26:37.978 --> 00:26:40.238
2014 und ich bin ja erst ein Jahr später

00:26:40.238 --> 00:26:41.398
zu PyTest dazugekommen.

00:26:42.338 --> 00:26:44.298
Also, ja, TPT lügt bei

00:26:44.298 --> 00:26:46.258
Python regelmäßig. Das denkt zum Beispiel auch, dass

00:26:46.258 --> 00:26:48.198
irgendwelche anderen Menschen einen Python-Podcast machen würden,

00:26:48.198 --> 00:26:49.878
die es nicht gehört haben. Aber hey.

00:26:51.438 --> 00:26:52.238
Ja, ich habe

00:26:52.238 --> 00:26:54.058
tatsächlich mal rumgegraben in

00:26:54.058 --> 00:26:55.998
Mailing-List-Archiven und

00:26:55.998 --> 00:26:58.078
rausgefunden, warum das so eine Panflöte

00:26:58.078 --> 00:26:59.638
ist. Ach okay, das ist was.

00:26:59.658 --> 00:27:01.998
Soll nämlich tatsächlich an diesem Testing

00:27:01.998 --> 00:27:03.698
Goat als Maskottchen

00:27:03.698 --> 00:27:05.558
auf diesem Buch anknüpfen,

00:27:05.878 --> 00:27:07.918
weil Panflöten eben genutzt

00:27:07.918 --> 00:27:09.998
wurden wohl, um

00:27:10.718 --> 00:27:12.118
Ziegen zu

00:27:12.118 --> 00:27:13.598
herden, wie sagt man denn noch

00:27:13.598 --> 00:27:14.458
in Deutsch?

00:27:15.278 --> 00:27:16.858
Züten, jaja.

00:27:18.418 --> 00:27:18.838
Hm.

00:27:19.858 --> 00:27:20.838
Ja. Ja, ich

00:27:20.838 --> 00:27:23.598
fand das mit dem Chat-Video dann ganz witzig.

00:27:23.598 --> 00:27:25.358
Ich hab danach nochmal so ein bisschen nachgehakt

00:27:25.358 --> 00:27:26.838
und finden so, nö, das war nicht ich.

00:27:27.378 --> 00:27:29.398
Und dann meint er, ja, nee, es tut mir leid,

00:27:29.538 --> 00:27:30.738
es war Armin Ronacher.

00:27:31.258 --> 00:27:31.658
Ach so.

00:27:34.358 --> 00:27:35.378
Und da fand ich halt auch,

00:27:35.558 --> 00:27:37.418
nö. Und dann meint

00:27:37.418 --> 00:27:39.578
er irgendwas von einem Daniel Urstöger,

00:27:39.738 --> 00:27:41.478
auch bekannt als Blue Logo,

00:27:41.578 --> 00:27:43.398
habe ich gesucht, nichts gefunden zu der

00:27:43.398 --> 00:27:45.318
Person und fand immer noch, nee, kann nicht

00:27:45.318 --> 00:27:47.318
sein. Und dann fand er immer noch,

00:27:47.378 --> 00:27:48.898
ja, tut mir wirklich leid und so.

00:27:49.038 --> 00:27:51.298
Das war von Daniel Haller gemacht,

00:27:51.478 --> 00:27:52.418
was auch nicht stimmt.

00:27:54.138 --> 00:27:55.198
Mir sei, ich habe gerade auch

00:27:55.198 --> 00:27:57.038
nochmal gefragt und mir sagt es,

00:27:57.198 --> 00:27:59.438
dass es nicht genau weiß, weil es von einem Community-Wettbewerb

00:27:59.438 --> 00:28:00.258
stammen würde.

00:28:02.538 --> 00:28:03.238
Ja, dann hast du

00:28:03.238 --> 00:28:05.278
wahrscheinlich dieses GPT-4-Modell

00:28:05.278 --> 00:28:07.698
oder manchmal mit dem GPT-

00:28:07.698 --> 00:28:08.938
das 3.5, okay, interessant.

00:28:09.378 --> 00:28:11.078
Ja, das ist halt, weil er sich

00:28:11.078 --> 00:28:12.498
manchmal aus der Fantasie teilt.

00:28:12.918 --> 00:28:13.498
Ja, gut.

00:28:15.538 --> 00:28:17.258
Sicheres Auftreten bei vollkommener Ahnung

00:28:17.258 --> 00:28:19.378
zu Bescheid, Jochen. Was fällt dir dazu ein?

00:28:20.758 --> 00:28:21.718
Dass mir auf jeden Fall

00:28:21.718 --> 00:28:22.978
die Pahnpfirte besser gefällt als

00:28:22.978 --> 00:28:24.778
ein Schererhund als Logo für PyTest.

00:28:25.198 --> 00:28:28.738
Ja, die Python-Feld ist super

00:28:28.738 --> 00:28:30.518
Ja, was

00:28:30.518 --> 00:28:33.158
haben wir denn so an Dingen, die man da

00:28:33.158 --> 00:28:35.178
über die man mal, naja, das würde mich auch mal

00:28:35.178 --> 00:28:37.218
interessieren, genau, du machst viele PyTest-Schulungen

00:28:37.218 --> 00:28:39.078
geht das überhaupt?

00:28:39.218 --> 00:28:41.018
Also ich habe irgendwie so ein bisschen, ich mache auch manchmal

00:28:41.018 --> 00:28:43.038
Schulungen, auch so Python-Einschulungen oder halt auch

00:28:43.038 --> 00:28:44.738
mal zu speziellen Themen

00:28:44.738 --> 00:28:47.178
und ich habe immer so das Gefühl, ich weiß

00:28:47.178 --> 00:28:48.498
nicht so genau, ob das

00:28:48.498 --> 00:28:50.558
wie man da am besten

00:28:50.558 --> 00:28:53.318
Wert irgendwie schafft

00:28:53.318 --> 00:28:55.178
für die Leute, die darin teilnehmen, weil ich habe manchmal

00:28:55.178 --> 00:28:58.318
und das Gefühl, die sind dann halt dann zwei Tage oder drei Tage da

00:28:58.318 --> 00:29:03.158
und dann machen sie das dann aber doch wieder so, wie sie das kennen irgendwie,

00:29:03.258 --> 00:29:04.158
wenn sie wieder da weg sind.

00:29:04.598 --> 00:29:07.158
Und gerade bei so Testframe Development ist es halt,

00:29:07.498 --> 00:29:09.838
habe ich das Gefühl, oder überhaupt beim Testen,

00:29:10.178 --> 00:29:14.118
so ein Ding, wo sich das erst so über die Zeit irgendwie einstellt,

00:29:14.618 --> 00:29:16.698
wo man das schlecht irgendwie so einmal in,

00:29:17.198 --> 00:29:18.878
so musst du das halt machen und dann,

00:29:18.878 --> 00:29:20.758
sondern es ist mehr so ein Ding, so ein, so ein, so ein,

00:29:20.758 --> 00:29:22.538
wegschmeißen nochmal machen, wegschmeißen nochmal machen,

00:29:22.698 --> 00:29:23.358
wegschmeißen nochmal machen.

00:29:23.378 --> 00:29:24.558
Ja, aber da muss ich halt so ein bisschen dran gewöhnen

00:29:24.558 --> 00:29:26.598
und das muss halt über eine längere Zeit irgendwie

00:29:26.598 --> 00:29:28.598
passieren und ich habe da noch nicht so einen Dreh gefunden,

00:29:28.718 --> 00:29:29.558
wie man das am besten vermitteln kann.

00:29:31.078 --> 00:29:31.798
Ja, ich sage,

00:29:32.118 --> 00:29:33.818
das ist den Leuten schon auch so,

00:29:34.758 --> 00:29:36.458
es ist auch irgendwie viel Erfahrung

00:29:36.458 --> 00:29:38.098
dahinter, die kann ich euch nicht abnehmen.

00:29:38.498 --> 00:29:40.458
Aber ich kann euch halt erstmal die Werkzeuge

00:29:40.458 --> 00:29:42.538
in die Hand geben und euch

00:29:42.538 --> 00:29:44.298
einfach mal zeigen, was kann man an sich

00:29:44.298 --> 00:29:46.438
vielleicht eher ein bisschen abstrakter mit

00:29:46.438 --> 00:29:48.798
PyTest überhaupt machen, was sind so die Möglichkeiten.

00:29:49.738 --> 00:29:50.598
Wie man die dann

00:29:50.598 --> 00:29:52.398
anwendet auf die konkrete Fälle,

00:29:52.398 --> 00:29:54.338
die die Leute da haben, steht dann teilweise

00:29:54.338 --> 00:29:56.018
schon nochmal ein bisschen auf einem anderen Blatt.

00:29:56.878 --> 00:29:58.258
Aber ich finde es schon ganz nützlich,

00:29:58.498 --> 00:30:00.238
dass die Leute erzählen, was gibt es denn überhaupt.

00:30:01.778 --> 00:30:01.898
Ja.

00:30:02.998 --> 00:30:04.358
Da habe ich vielleicht noch eine

00:30:04.358 --> 00:30:06.378
kurze Geschichte auch, wie das mit

00:30:06.378 --> 00:30:07.638
diesen Trainings angefangen hat.

00:30:08.278 --> 00:30:10.438
Das war nämlich auch ganz

00:30:10.438 --> 00:30:12.418
witzig. Das war, als ich PyTest

00:30:12.418 --> 00:30:14.298
erst ein paar Monate gebraucht habe, auch noch

00:30:14.298 --> 00:30:15.498
irgendwie im 2015.

00:30:16.938 --> 00:30:17.738
Und zwar zu

00:30:17.738 --> 00:30:19.958
Europython da in Bilbao,

00:30:20.698 --> 00:30:21.358
also Spanien.

00:30:22.718 --> 00:30:24.018
Da wurde ich von

00:30:24.018 --> 00:30:25.718
Holger Krekel, also nicht ich, aber

00:30:25.718 --> 00:30:27.758
Holger Krekel, also so der

00:30:27.758 --> 00:30:29.398
Vater von PyTest,

00:30:30.138 --> 00:30:32.138
der hat halt auf der Mailing-Liste gefragt,

00:30:32.258 --> 00:30:34.078
ob jemand dieses Training übernehmen kann

00:30:34.078 --> 00:30:36.018
an der EuroPython, weil er war

00:30:36.018 --> 00:30:37.478
irgendwie verhindert kurzfristig

00:30:37.478 --> 00:30:39.718
und es hat sich dann niemand gemeldet.

00:30:39.838 --> 00:30:41.038
Und ich fand halt so, ja, hm,

00:30:41.778 --> 00:30:43.458
das ist irgendwie Material da,

00:30:43.698 --> 00:30:45.898
Spanien klingt auch irgendwie toll, ich war noch

00:30:45.898 --> 00:30:47.558
nie auf irgendwie einer Python-Konferenz.

00:30:48.238 --> 00:30:49.238
Ja, machen wir.

00:30:50.578 --> 00:30:51.878
Dann im gleichen Jahr

00:30:51.878 --> 00:30:53.878
noch das erste Firmentraining dann von

00:30:53.878 --> 00:30:58.178
übernommen, weil er eh langsam aufgehört hat mit PyTest und zu anderen Projekten

00:30:58.178 --> 00:31:02.098
übergegangen ist. Und seit da dann basierend auf

00:31:02.098 --> 00:31:04.398
seinen Materialien das halt immer weiterentwickelt.

00:31:05.698 --> 00:31:09.678
Das klingt gut. Also da sind auch viele interessante Sachen und ich würde auch

00:31:09.678 --> 00:31:13.978
die einzelnen auch nochmal vielleicht kurz anschneiden, dass man so ein bisschen drüber erklärt, für die Menschen,

00:31:14.138 --> 00:31:17.958
die das noch nicht so kennen. Wollen wir uns eine Struktur geben,

00:31:17.958 --> 00:31:22.018
wie wir anfangen? Weiß ich nicht, nochmal reden, wie man vielleicht Pictures am besten macht oder was das überhaupt ist

00:31:22.018 --> 00:31:25.898
oder ob man die braucht oder wie man die baut oder

00:31:25.898 --> 00:31:29.918
und dann irgendwann vielleicht über diese ganzen Plugins oder so

00:31:29.918 --> 00:31:34.078
ein paar extra Sachen geht. Es gibt ja wunderschöne Sachen,

00:31:34.418 --> 00:31:38.118
die ich auch am Anfang nicht kannte. Das letzte, wo ich erst mich

00:31:38.118 --> 00:31:42.218
so ein bisschen gesträubt hatte, war Hypothesis. Das habe ich dann durch deine Veranstaltung

00:31:42.218 --> 00:31:45.338
lieber Florian nochmal eingebaut und war überrascht,

00:31:45.678 --> 00:31:48.658
ich habe noch so ein paar Bugs angefressen.

00:31:48.658 --> 00:31:50.598
und so. Oh, die habe ich jetzt noch nicht

00:31:50.598 --> 00:31:51.918
gesehen. Und ja,

00:31:53.598 --> 00:31:54.618
da kommt man so ein bisschen auch an die

00:31:54.618 --> 00:31:56.558
Grenzen dessen, was Python so kann.

00:31:57.398 --> 00:31:58.778
Und ja, ich weiß nicht,

00:31:58.798 --> 00:31:59.738
wo würdest du denn anfangen

00:31:59.738 --> 00:32:01.578
bei PyTest?

00:32:02.718 --> 00:32:04.198
Ich würde, glaube ich, jetzt tatsächlich

00:32:04.198 --> 00:32:06.698
nicht generell über PyTest, aber ich würde

00:32:06.698 --> 00:32:08.358
nochmal kurz gerne bei Coverage

00:32:08.358 --> 00:32:10.558
einhaken, weil das Thema schon

00:32:10.558 --> 00:32:12.618
gehabt haben und vielleicht nicht alle wissen, was

00:32:12.618 --> 00:32:13.378
das eigentlich ist.

00:32:14.898 --> 00:32:16.558
Da freue ich mich auch so rum bei den

00:32:16.558 --> 00:32:18.638
Firmenkursen und oft so

00:32:18.638 --> 00:32:48.618
und wie man das testen kann.

00:32:48.638 --> 00:32:50.738
Prozent Coverage, also der ganze Kult ist durchgelaufen,

00:32:50.838 --> 00:32:51.858
aber es ist trotzdem irgendwas kaputt.

00:32:53.298 --> 00:32:54.778
Genau. Kann einem halt auch passieren, ja.

00:32:56.018 --> 00:32:56.758
Auch schwierig,

00:32:57.138 --> 00:32:58.578
da Prozent Coverage

00:32:58.578 --> 00:33:00.518
gerade in einem Team sich irgendwie aufs Ziel

00:33:00.518 --> 00:33:02.578
zu setzen, weil dann wird es

00:33:02.578 --> 00:33:04.478
bestimmt Leute geben, die dann einfach diese Zahl

00:33:04.478 --> 00:33:06.558
hochtreiben, ohne wirklich noch gute Tests zu

00:33:06.558 --> 00:33:08.538
schreiben. Ja, ja, genau, weil ja, das würde ich auch

00:33:08.538 --> 00:33:09.958
sagen, wenn man es halt nur macht, um irgendwie

00:33:09.958 --> 00:33:11.578
irgendeinen Ast nochmal zu

00:33:11.578 --> 00:33:14.458
durchzuwandern, ohne dass es halt irgendwas

00:33:14.458 --> 00:33:15.238
bringt, ist halt blöd.

00:33:16.678 --> 00:33:17.918
Aber gibt es ja sowas, wo er sagen würde,

00:33:17.918 --> 00:33:20.098
aus eigenen Projekten, so Pi mal Daumen,

00:33:20.178 --> 00:33:21.418
so eine Coverage ist okay?

00:33:24.878 --> 00:33:25.418
Ich würde,

00:33:25.758 --> 00:33:28.018
also ich weiß nicht, also meistens, wenn ich nicht drauf

00:33:28.018 --> 00:33:29.618
achte, lande ich irgendwo so bei

00:33:29.618 --> 00:33:31.838
ein bisschen über 80 Prozent oder sowas.

00:33:33.478 --> 00:33:33.978
Ja, 80

00:33:33.978 --> 00:33:36.318
wäre jetzt auch so meine erste Reaktion gewesen.

00:33:36.878 --> 00:33:37.898
Also ich würde sagen, wenn man schon zwei

00:33:37.898 --> 00:33:39.838
Tests schreibt oder so, die so ein bisschen das machen, was man

00:33:39.838 --> 00:33:42.098
testen, was man macht, dann sind die schon mal über 60, 70

00:33:42.098 --> 00:33:42.718
meistens drüber.

00:33:43.958 --> 00:33:46.038
Das weiß ich nicht, aber... Ja, je nachdem, wie groß das Projekt ist

00:33:46.038 --> 00:33:46.198
natürlich.

00:33:46.198 --> 00:33:48.398
Ja, ja. Also klar,

00:33:48.498 --> 00:33:50.238
am Anfang hast du einfach viel mehr Gewinn, also

00:33:50.238 --> 00:33:52.298
so ein paar Tests, die halt bei der

00:33:52.298 --> 00:33:54.378
Web-Applikation jetzt die Views einfach nur durchgehen

00:33:54.378 --> 00:33:56.158
und gucken, ob ein Okay zurückkommt, irgendwie in den

00:33:56.158 --> 00:33:58.098
Standardfällen, da hast du halt sehr wenig

00:33:58.098 --> 00:34:00.358
Tests geschrieben und viel Gewinn quasi, weil

00:34:00.358 --> 00:34:02.358
wenn das kaputt geht, und das

00:34:02.358 --> 00:34:04.158
wird dann halt immer weniger irgendwann und irgendwann

00:34:04.158 --> 00:34:06.478
ist dann natürlich ein Punkt erreicht, wo es halt eigentlich keinen Sinn

00:34:06.478 --> 00:34:08.078
mehr macht und man aufhören kann, aber

00:34:08.078 --> 00:34:10.518
wann der erreicht ist, keine Ahnung,

00:34:10.677 --> 00:34:12.177
schwer zu sagen. Also

00:34:12.177 --> 00:34:12.758
ja.

00:34:12.758 --> 00:34:35.738
Ja, am Schluss muss man sich dann auch einfach mal so die Daten dahinter anschauen und mal schauen, was habe ich denn noch nicht getestet. Da kann es eben sein, es wurde einfach vergessen, es ist irgendwie eine Fehlercondition, die es vielleicht ganz gut ist, die zu testen. Oder es kann halt sein, es ist eben ein Code, der nicht einfach testbar ist und da muss man sich überlegen, ist es davon wert.

00:34:35.738 --> 00:34:57.178
Es gibt halt so zwei, ich würde sagen, Dinge, die es ein bisschen schwierig machen. Und zwar klar, man kann jetzt natürlich sehr viel einfacher Tests schreiben, wenn man ganz klar weiß, wie es von einer kleinen Funktion, von irgendeiner Closure irgendwie der Contract ist. Also man weiß, was reingehen, was rausgehen muss. Was halt auch bedeutet, dass man dazu tendiert, die relativ statisch zum Beispiel zu typisieren oder zumindest die Type Annotations dann nochmal abzufangen oder irgendwie sowas.

00:34:57.178 --> 00:35:00.938
Naja gut, das macht ja jetzt wenig Sinn, würde ich sagen, wenn du die Type Annotations nochmal testest.

00:35:00.938 --> 00:35:21.238
Ja, nein, aber du wirst halt, dass das, was reinkommt, dann auch dem entspricht vielleicht, oder dass man halt das eng zogt. Das bedeutet aber halt, dass man auch die Dynamik verliert oder die Flexibilität, auch jetzt irgendwie, wenn man jetzt API schreibt und dann irgendwie die Daten validieren möchte, klar kann man jetzt ganz streng sein und jedes Mal dann, wenn es nicht passt, einfach zurückgeben, okay, danke, du darfst nicht oder so.

00:35:21.238 --> 00:35:23.678
Ich glaube, das läuft jetzt quasi

00:35:23.678 --> 00:35:25.538
darauf hinaus, wie sollte so eine Test

00:35:25.538 --> 00:35:27.998
es gibt ja diese Testpyramide

00:35:27.998 --> 00:35:29.078
wie sollte die aussehen

00:35:29.078 --> 00:35:31.058
quasi, ja

00:35:31.058 --> 00:35:33.698
weil sozusagen, also ja

00:35:33.698 --> 00:35:35.877
dass man halt viele Unit-Tests

00:35:35.877 --> 00:35:37.758
hat, irgendwie dann weniger

00:35:37.758 --> 00:35:39.498
irgendwie Tests, die halt

00:35:39.498 --> 00:35:41.938
größere Sachen testen und dann halt nur ganz wenige

00:35:41.938 --> 00:35:43.638
irgendwie so

00:35:43.638 --> 00:35:44.978
End-to-End-Tests oder so

00:35:44.978 --> 00:35:47.337
Man kann natürlich jetzt sicher auch mit sowas wie

00:35:47.337 --> 00:35:50.058
PrayWrite oder sowas eine komplette Frontend-Integrationsstrecke

00:35:50.058 --> 00:35:52.038
bauen, die jedes Mal dann testet, ob die Farbe

00:35:52.038 --> 00:35:53.738
bei dem Button sich geändert hat und

00:35:53.738 --> 00:35:55.698
ob weiße, nicht meterlinks oder rechts sind.

00:35:55.837 --> 00:35:57.558
Aber wenn halt irgendeine Änderung von irgendeinem Designer kommt,

00:35:57.658 --> 00:35:59.178
dann eine ganze Pipeline sieht man auseinanderfliegen,

00:35:59.518 --> 00:36:00.938
ist wahrscheinlich eher zu viel.

00:36:02.598 --> 00:36:03.238
So, aber

00:36:03.238 --> 00:36:05.698
man muss halt irgendwie so

00:36:05.698 --> 00:36:07.758
sich überlegen, was der Anwendungsfall, ob der sinnvoll

00:36:07.758 --> 00:36:09.618
ist halt auch. Also ob es halt einen Sinn

00:36:09.618 --> 00:36:11.778
hat, dass man eine breite

00:36:11.778 --> 00:36:13.658
Anwendungsfall hat oder ob man das so enger scopen

00:36:13.658 --> 00:36:15.698
möchte. Und das

00:36:15.698 --> 00:36:17.678
würdet ihr wahrscheinlich am besten wissen, wenn ihr Anwendungen

00:36:17.678 --> 00:36:19.658
baut, an welchen Stellen die nicht auseinanderfliegen

00:36:19.658 --> 00:36:20.958
sollte. Also wenn ihr irgendwas macht, was

00:36:20.958 --> 00:36:23.478
wichtig ist, wo Leben dran hängt oder

00:36:23.478 --> 00:36:25.718
was teuer ist oder sowas, dann sollte man da vielleicht ein bisschen

00:36:25.718 --> 00:36:27.438
mehr Hörnschmalz reinstecken,

00:36:27.538 --> 00:36:29.638
das so ein bisschen sauberer zu

00:36:29.638 --> 00:36:31.658
programmieren. Und ich habe immer das

00:36:31.658 --> 00:36:33.618
Gefühl, also Tests haben mir auch sehr geholfen,

00:36:33.698 --> 00:36:35.558
so die Architektur, mit der ich überhaupt Programme

00:36:35.558 --> 00:36:36.778
schreibe, so ein bisschen zu überdenken,

00:36:37.558 --> 00:36:39.458
weil man halt merkt, dass man halt so

00:36:39.458 --> 00:36:41.357
große Module oder sowas oder Dinge, die

00:36:41.357 --> 00:36:43.458
viel machen, dass die schwierig halt werden.

00:36:43.658 --> 00:36:45.438
Also A, zu testen, aber es vielleicht auch eine doofe

00:36:45.438 --> 00:36:47.418
Idee ist, wenn in einer Methode oder

00:36:47.418 --> 00:36:49.578
in einer Funktion so super viele Sachen gleichzeitig passieren.

00:36:49.658 --> 00:36:50.898
und solche Dinge.

00:36:51.298 --> 00:36:55.418
Und da kommen wir halt auch wieder zu Coverage.

00:36:55.578 --> 00:36:56.958
Wenn man halt so viel Zeugs hat,

00:36:57.498 --> 00:36:58.857
was auf einmal passiert,

00:36:58.998 --> 00:37:01.877
sich so von diesem Ein-Ding-für-eine-Sache-Prinzip

00:37:01.877 --> 00:37:03.798
verabschiedet, dann wird das

00:37:03.798 --> 00:37:05.398
halt auch relativ schwierig zu testen.

00:37:06.318 --> 00:37:07.837
Oder überhaupt dahin zu kommen,

00:37:07.938 --> 00:37:09.658
dass die Sachen so passieren. Oder dass man die Bugs

00:37:09.658 --> 00:37:10.098
dann findet.

00:37:12.158 --> 00:37:13.398
Ja, aber ich

00:37:13.398 --> 00:37:15.218
fürchte, man kann nicht einfach sagen,

00:37:15.638 --> 00:37:16.558
man muss das halt so machen.

00:37:17.258 --> 00:37:19.278
Weil das sind so widerstreitende

00:37:19.278 --> 00:37:20.598
Dinge und so Trade-offs.

00:37:21.058 --> 00:37:22.938
Also ich würde ja auch zustellen,

00:37:23.058 --> 00:37:24.918
genau, das ist halt, also das ist auch etwas, was beim

00:37:24.918 --> 00:37:26.278
Testen, was ich gut finde,

00:37:27.038 --> 00:37:29.158
dass man halt irgendwie so ein bisschen in die Richtung gedrängt

00:37:29.158 --> 00:37:30.758
wird, sich darüber Gedanken zu machen, wie man

00:37:30.758 --> 00:37:32.818
Sachen halt so hinschreibt, dass man sie

00:37:32.818 --> 00:37:34.938
gut testen kann und irgendwann hat man das dann halt auch

00:37:34.938 --> 00:37:36.638
so ein bisschen verinnerlicht, dass man, weiß man schon,

00:37:37.198 --> 00:37:38.837
wie man am besten Dinge so hinschreibt, dass

00:37:38.837 --> 00:37:40.778
hinterher die Tests sehr, sehr, sehr einfach

00:37:40.778 --> 00:37:42.958
hinzuschreiben sind und wenn das nicht geht,

00:37:43.118 --> 00:37:44.837
dann ist das halt auch einfach nichts, was man halt

00:37:44.837 --> 00:37:46.458
so schreiben sollte wahrscheinlich.

00:37:46.618 --> 00:37:48.018
Auf der anderen Seite, also

00:37:48.018 --> 00:37:58.098
Also es ist halt auch so, wäre es halt schön oder elegant von der Aspektur her, wenn man jetzt halt eher schmale und tiefe Funktionen hat.

00:38:00.138 --> 00:38:04.178
Ja, also sozusagen, aber die sind halt schwer zu testen, auch unter Umständen.

00:38:04.498 --> 00:38:16.837
Also du kannst natürlich auch viele Funktionen, also dass es etwas super zu testen ist, muss jetzt nicht unbedingt bedeuten, dass es halt auch total elegant ist, zum Beispiel zu verwenden.

00:38:18.018 --> 00:38:31.918
Also es kann sein, dass zum Beispiel, nehmen wir mal an, ein Beispiel für eine sehr schlechte API, die ganze Java-File irgendwie buffert, reader, irgendwas sonst was API, also ich könnte mir vorstellen, dass das relativ einfach zu testen ist, aber es ist halt ein Albtraum, das zu benutzen.

00:38:31.918 --> 00:38:34.058
und die, nehmen wir an,

00:38:34.158 --> 00:38:36.038
Unix-File-API oder halt auch irgendwie,

00:38:36.118 --> 00:38:37.918
keine Ahnung, Request-API in Python,

00:38:38.258 --> 00:38:40.357
die ist halt schön, weil die ist halt

00:38:40.357 --> 00:38:42.158
schmal und tief, aber

00:38:42.158 --> 00:38:44.258
ich könnte mir vorstellen, dass Request zu testen eventuell

00:38:44.258 --> 00:38:46.018
ziemlicher Schmerz ist.

00:38:46.857 --> 00:38:48.478
Es hängt halt davon ab,

00:38:49.518 --> 00:38:50.598
was dein Anwendungsfall

00:38:50.598 --> 00:38:52.138
ist, ob das jetzt, also wenn

00:38:52.138 --> 00:38:54.238
du sagst jetzt irgendwie, das ist eine interne Funktion

00:38:54.238 --> 00:38:56.258
und da ist es schön,

00:38:56.377 --> 00:38:58.058
wenn man die einfach testen kann, dann

00:38:58.058 --> 00:38:59.857
macht es halt Sinn, das vielleicht so zu machen, aber wenn

00:38:59.857 --> 00:39:01.978
wenn das jetzt was ist, was nach außen geht

00:39:01.978 --> 00:39:04.337
wo User dann halt den Schmerz

00:39:04.337 --> 00:39:06.058
haben, dass du es einfach zu testen hast

00:39:06.058 --> 00:39:07.318
dann muss man sagen, naja, nee

00:39:07.318 --> 00:39:09.638
dann muss es halt für User einfach zu verwenden sein

00:39:09.638 --> 00:39:11.818
und wenn das halt bedeutet, dass es schmerzhaft ist

00:39:11.818 --> 00:39:13.758
das zu testen, dann ist das halt so

00:39:13.758 --> 00:39:15.738
weil wichtiger ist an der Stelle die User Experience

00:39:15.738 --> 00:39:17.857
also es kommt halt drauf an, denke ich

00:39:19.218 --> 00:39:19.978
ja

00:39:19.978 --> 00:39:23.958
ja, um auch vielleicht

00:39:23.958 --> 00:39:25.998
nochmal bei dieser Testing Pyramid einzuhängen

00:39:25.998 --> 00:39:27.877
ich finde

00:39:27.877 --> 00:39:28.618
da immer so

00:39:28.618 --> 00:39:31.158
Ich finde das ein bisschen zu kurz gedacht

00:39:31.158 --> 00:39:34.078
Es kommt halt immer sehr darauf an, was man testet

00:39:34.078 --> 00:39:35.458
und man soll sich halt

00:39:35.458 --> 00:39:37.318
zu den Vor- und Nachteilen von diesen

00:39:37.318 --> 00:39:39.298
Größen von Tests

00:39:39.298 --> 00:39:41.558
bewusst sein, aber ich finde

00:39:41.558 --> 00:39:43.598
zunächst, man kann immer

00:39:43.598 --> 00:39:45.418
sagen, dass die eine Art ist besser

00:39:45.418 --> 00:39:46.258
wie die andere Art

00:39:46.258 --> 00:39:49.718
Wenn ich jetzt ein Command-Line-Tool

00:39:49.718 --> 00:39:51.558
teste, bietet

00:39:51.558 --> 00:39:52.978
es sich vielleicht an, da eher

00:39:52.978 --> 00:39:55.598
Intuent-Tests zu schreiben, weil ich dann wirklich auch den Output

00:39:55.598 --> 00:39:56.598
und so testen kann

00:39:56.598 --> 00:39:58.238
und

00:39:58.238 --> 00:40:00.118
eher sparsam, so wie

00:40:00.118 --> 00:40:02.357
für einzelne Funktionen Unitests

00:40:02.357 --> 00:40:02.898
zu schreiben.

00:40:03.818 --> 00:40:05.098
Oder auch, ich

00:40:05.098 --> 00:40:08.318
bin viel auch jetzt bei Firmen für die

00:40:08.318 --> 00:40:10.598
Kurse, die eigentlich gar keinen Python-Code

00:40:10.598 --> 00:40:12.638
mit PyTest testen. Das fand ich auch ganz spannend.

00:40:12.638 --> 00:40:14.138
Ja, das ist auch total interessant.

00:40:15.318 --> 00:40:16.658
Sondern die beispielsweise

00:40:16.658 --> 00:40:19.058
Waschmaschinen mit PyTest testen.

00:40:20.118 --> 00:40:20.658
Also da

00:40:20.658 --> 00:40:22.578
halt eine Waschmaschine haben, wo

00:40:22.578 --> 00:40:23.938
deren Firmware drauf läuft

00:40:23.938 --> 00:40:26.018
läuft und die

00:40:26.018 --> 00:40:26.978
wollen sie halt testen.

00:40:28.178 --> 00:40:29.918
Und wollen halt dazu

00:40:29.918 --> 00:40:31.818
PyTest nutzen, weil es eben

00:40:31.818 --> 00:40:33.958
zusammen mit Python ein relativ einfaches

00:40:33.958 --> 00:40:36.018
und flexibles Werkzeug darstellt.

00:40:36.898 --> 00:40:37.818
Gucken, ob noch alles geht.

00:40:38.698 --> 00:40:40.018
Wenn man die richtigen

00:40:40.018 --> 00:40:41.618
Hälfte drückt und das richtige Programm läuft.

00:40:41.998 --> 00:40:43.837
Ja, und die testen halt einfach zu schreiben.

00:40:44.238 --> 00:40:45.918
Ja, das ist eine gute Idee.

00:40:46.978 --> 00:40:47.818
Oder bei einem Kunden

00:40:47.818 --> 00:40:50.038
von mir, um vielleicht

00:40:50.038 --> 00:40:51.998
dann gleich die Überleitung zu den Fixtures zu machen

00:40:51.998 --> 00:40:54.098
an der Stelle. Die nutzen

00:40:54.098 --> 00:40:55.877
eine PyTest-Fixture, um

00:40:55.877 --> 00:40:57.738
eine Klimakammer anzusteuern.

00:40:58.498 --> 00:41:00.238
Die haben so eine Klimakammer

00:41:00.238 --> 00:41:02.098
mit Elektronik drin und

00:41:02.098 --> 00:41:04.538
sagen dann halt, über eine PyTest-Fixture

00:41:04.538 --> 00:41:06.198
heizt mir das jetzt auf

00:41:06.198 --> 00:41:08.018
auf 30 Grad und dann lasse ich da

00:41:08.018 --> 00:41:10.078
meine Systemtests für

00:41:10.078 --> 00:41:10.998
dieses Gerät laufen.

00:41:12.118 --> 00:41:13.958
Wo auch wieder alles andere

00:41:13.958 --> 00:41:15.458
als Python-Code getestet wird.

00:41:16.918 --> 00:41:17.398
Ja.

00:41:18.598 --> 00:41:19.718
Ja, spannend, wenn man

00:41:19.718 --> 00:41:21.638
halt wirklich das mit in die Realität überträgt

00:41:21.638 --> 00:41:22.998
und quasi auch seine Hardware damit

00:41:22.998 --> 00:41:25.758
steuert, um die Testumgebung

00:41:25.758 --> 00:41:27.538
außerhalb des Rechners

00:41:27.538 --> 00:41:29.158
aufzubauen oder halt aufzuheizen.

00:41:30.138 --> 00:41:31.558
Bestimmen die Parameter, machen die das,

00:41:31.658 --> 00:41:31.998
was sie sollen.

00:41:33.158 --> 00:41:35.678
Und jetzt habe ich das

00:41:35.678 --> 00:41:37.058
vergessen, was ich eigentlich sagen wollte.

00:41:37.357 --> 00:41:39.218
Überall gibt es Fixschuss.

00:41:40.038 --> 00:41:41.458
Das auch, aber vorher noch.

00:41:42.018 --> 00:41:43.418
Was eigentlich mein Punkt war,

00:41:44.337 --> 00:41:45.718
da hat man ja dann gar keine

00:41:45.718 --> 00:41:47.498
Wahl, welche Größen von Tests

00:41:47.498 --> 00:41:49.558
man schreiben will. Also da schreibt man fast

00:41:49.558 --> 00:41:51.618
gezwungenermaßen dann eben Systemtests.

00:41:51.638 --> 00:41:52.898
oder so, End-to-End-Tests,

00:41:53.798 --> 00:41:55.898
kann er nicht mehr wirklich einzelne

00:41:55.898 --> 00:41:57.958
Funktionen dieses Geräts,

00:41:58.178 --> 00:41:59.798
also im Sinne eines Unitests,

00:42:00.278 --> 00:42:00.658
testen.

00:42:02.357 --> 00:42:03.698
Ja, im Grunde ist das ja auch schon so,

00:42:03.698 --> 00:42:05.738
wenn man PyTest zum Schreiben

00:42:05.738 --> 00:42:07.578
von End-to-End-Tests, was man ja auch machen kann, verwendet,

00:42:07.638 --> 00:42:09.837
wie zum Beispiel PyTest Playwright

00:42:09.837 --> 00:42:11.658
oder so, dann da ist ja auch eigentlich

00:42:11.658 --> 00:42:13.498
jeder Test im Grunde wäre weniger.

00:42:13.918 --> 00:42:15.418
Man muss halt den Browser aufmachen,

00:42:15.498 --> 00:42:16.857
dann da überhin und dann...

00:42:16.857 --> 00:42:17.357
Ja.

00:42:20.578 --> 00:42:21.458
Ja, von da

00:42:21.458 --> 00:42:23.198
finde ich so dieses Testing Pyramid. Ich meine,

00:42:23.317 --> 00:42:25.518
die Idee ist ja auch steinalt, um es mal zu sagen.

00:42:27.138 --> 00:42:27.698
Bin ich

00:42:27.698 --> 00:42:28.978
mit Vorsicht zu genießen.

00:42:30.778 --> 00:42:31.418
Dann aber

00:42:31.418 --> 00:42:33.278
vielleicht tatsächlich dazu, du fixtures und

00:42:33.278 --> 00:42:35.317
was fixtures sind und wie man die baut oder

00:42:35.317 --> 00:42:37.078
macht ihr das mit

00:42:37.078 --> 00:42:39.238
Factories oder macht ihr das ohne Factories

00:42:39.238 --> 00:42:41.518
oder sind Factories doof oder

00:42:41.518 --> 00:42:43.258
gibt es da so verschiedene Sachen und

00:42:43.258 --> 00:42:45.058
was sind überhaupt fixtures und

00:42:45.058 --> 00:42:47.518
ja, also vielleicht so fertige

00:42:47.518 --> 00:42:49.158
Dinge, die

00:42:49.158 --> 00:42:51.158
so tun, als wären sie etwas, was

00:42:51.158 --> 00:42:52.337
das Programm normalerweise kann.

00:42:52.898 --> 00:42:55.198
Das war jetzt ein bisschen abstrakt. Ich gebe dir ein einfaches Beispiel.

00:42:57.138 --> 00:42:58.877
Also wenn wir mit einem normalen Webclient

00:42:58.877 --> 00:43:00.357
zum Beispiel arbeiten würden, dann würde hier halt eine Fiktion

00:43:00.357 --> 00:43:02.958
der User und ein Client und dann guckt man, wie das

00:43:02.958 --> 00:43:03.458
interagiert.

00:43:06.118 --> 00:43:07.098
Ja, am Schluss ist

00:43:07.098 --> 00:43:07.758
eine Fixture

00:43:07.758 --> 00:43:10.898
im Prinzip einfach eine Funktion, die

00:43:10.898 --> 00:43:12.158
aus PyTest-Fixture

00:43:12.158 --> 00:43:14.778
markiert ist oder

00:43:14.778 --> 00:43:15.698
dekoriert ist.

00:43:17.098 --> 00:43:18.817
Und diese Fixture kann

00:43:18.817 --> 00:43:20.518
entweder irgendwelche Setup

00:43:20.518 --> 00:43:24.518
Schritte vornehmen für einen Test und oder

00:43:24.518 --> 00:43:27.018
irgendwelche Objekte für den Test bereitstellen.

00:43:28.198 --> 00:43:32.558
Das heißt, das kann jetzt sein, wenn ich irgendwo eine Config-Klasse

00:43:32.558 --> 00:43:36.538
habe, vielleicht in meinem Code, dann habe ich vielleicht in meinen Tests

00:43:36.538 --> 00:43:40.418
eben eine Config-Fixture, was mir eine sinnvoll

00:43:40.418 --> 00:43:44.298
konfigurierte Instanz gibt von dieser Config-Klasse.

00:43:45.518 --> 00:43:48.377
Oder in den Trainings habe ich das Beispiel von so einem

00:43:48.377 --> 00:43:50.718
R-Pan Calculator, den ich testen will.

00:43:50.898 --> 00:43:52.718
Der nimmt dann auch eine Config als Argument

00:43:52.718 --> 00:43:54.698
und sowas. Und damit ich

00:43:54.698 --> 00:43:56.638
einfach nur die Instanzierung

00:43:56.638 --> 00:43:58.698
von diesem R-Pan Calculator,

00:43:59.198 --> 00:44:00.518
also einfach ein Taschenrechner

00:44:00.518 --> 00:44:01.978
im Prinzip, in Python geschrieben,

00:44:02.798 --> 00:44:04.638
damit ich das nicht copy-pasten muss

00:44:04.638 --> 00:44:06.418
in jedem Test, mache ich mir eben so eine

00:44:06.418 --> 00:44:08.458
Fixture-Funktion, wo ich das

00:44:08.458 --> 00:44:10.337
alles aufsetze, zurückgebe

00:44:10.337 --> 00:44:12.478
und Tests können dann diese

00:44:12.478 --> 00:44:13.538
Fixture eben nutzen.

00:44:14.438 --> 00:44:16.598
Mit dem Ziel eben so diese Setup-Schritte

00:44:16.598 --> 00:44:19.638
schön zu isolieren aus den Testfunktionen.

00:44:19.658 --> 00:44:21.317
Also man baut sich quasi das Objekt, das die

00:44:21.317 --> 00:44:23.337
API bereitstellt, einmal irgendwie mit den

00:44:23.337 --> 00:44:25.158
Parametern nach, wie man sie in echt auch gerne hätte,

00:44:25.817 --> 00:44:27.398
um die dann in dem Test benutzen zu können,

00:44:27.478 --> 00:44:29.078
zu gucken, ob die Ergebnisse, die man erwartet,

00:44:29.218 --> 00:44:30.817
dem entsprechen, was man möchte.

00:44:31.798 --> 00:44:32.038
Genau.

00:44:33.558 --> 00:44:35.238
Ja, schwierig, das jetzt so in paar

00:44:35.238 --> 00:44:37.238
Sätze zu fassen. Ja, ich finde das auch sehr

00:44:37.238 --> 00:44:39.218
abstrakt halt. Also wenn man das in Probe sieht, dann wird das

00:44:39.218 --> 00:44:41.158
relativ klar. Die Spezialität bei

00:44:41.158 --> 00:44:42.837
PyTest Fixers ist halt, dass die so

00:44:42.837 --> 00:44:44.498
diese magische

00:44:44.498 --> 00:44:46.837
Dependency Injection gibt, sodass man halt

00:44:46.837 --> 00:44:48.918
einfach nur den Namen der Fix

00:44:48.918 --> 00:44:51.018
in die Parameter

00:44:51.018 --> 00:44:52.377
vom Test schreibt und dann

00:44:52.377 --> 00:44:53.877
das automatisch ausgeführt wird.

00:44:53.877 --> 00:44:56.618
Genau, dafür schreibt man die Funktion ja quasi in den ConvTest einfach rein.

00:44:56.978 --> 00:44:58.258
Ja, nö, musst du nicht.

00:44:58.258 --> 00:45:01.098
Ja, aber auch gute Frage, ist das eine gute Idee?

00:45:01.377 --> 00:45:01.558
Und so.

00:45:02.498 --> 00:45:03.038
Hängt davon ab.

00:45:04.238 --> 00:45:06.078
Aber es ist halt,

00:45:06.658 --> 00:45:08.918
also ich weiß auch nicht, ob man das heute nochmal machen würde,

00:45:08.978 --> 00:45:11.158
wenn man das nochmal designt, weil das ist schon sehr magisch.

00:45:11.718 --> 00:45:12.618
Und ich meine,

00:45:12.618 --> 00:45:14.857
ansonsten hat man ja, wenn man jetzt eine Funktion einfach

00:45:14.857 --> 00:45:16.738
aufrufen würde oder so, haben ja auch Support in der IDE,

00:45:16.857 --> 00:45:18.238
dass man draufklicken kann und landet dann da.

00:45:19.238 --> 00:45:20.738
Also bei PyCharm geht das zum Beispiel, dass man

00:45:20.738 --> 00:45:21.638
halt auf einfach eine

00:45:21.638 --> 00:45:24.498
Fixture in PyTest klickt und dann halt

00:45:24.498 --> 00:45:25.938
im richtigen Code landet.

00:45:26.618 --> 00:45:28.898
Aber das ist halt natürlich irgendwie nur

00:45:28.898 --> 00:45:30.898
dadurch, dass da jemand die Arbeit investiert

00:45:30.898 --> 00:45:32.658
hat, irgendwie das

00:45:32.658 --> 00:45:34.058
parsen zu können und so.

00:45:34.438 --> 00:45:36.298
Also das wird wahrscheinlich nicht überall funktionieren.

00:45:36.798 --> 00:45:38.638
Es gibt auch eine Extension für andere Editoren

00:45:38.638 --> 00:45:39.418
auf deiner Wahl.

00:45:39.738 --> 00:45:42.558
Es ist schon eigenartig, ja.

00:45:42.618 --> 00:45:43.538
Also ich sag so, dass

00:45:43.538 --> 00:45:46.377
inzwischen hab ich's glaube ich raus, wie ich das

00:45:46.377 --> 00:45:48.458
den Leuten erkläre, dass das passt.

00:45:49.238 --> 00:45:50.498
Aber gerade am Anfang mit

00:45:50.498 --> 00:45:52.377
den Trainings war das so der Punkt, wo ich

00:45:52.377 --> 00:45:54.317
sagen musste, ja, ich werde auch jetzt

00:45:54.317 --> 00:45:56.298
erstmal verwirren und irgendwann werde ich es

00:45:56.298 --> 00:45:58.658
verstehen, aber nicht gerade vom ersten Satz.

00:45:58.978 --> 00:46:00.337
Ja, ich fand das auch sehr, sehr schwierig, also

00:46:00.337 --> 00:46:02.398
vor allem diesen Unterschied zwischen Modul-Scope,

00:46:02.638 --> 00:46:04.498
Class-Based-Scope und Function-Based-Scope

00:46:04.498 --> 00:46:06.357
Fixtures und sowas. Und

00:46:06.357 --> 00:46:08.258
erstmal zu verstehen, dass halt eine Fixture irgendwie eigentlich

00:46:08.258 --> 00:46:10.518
ein Generator ist, der irgendwie halt dieses Setup und Teardown

00:46:10.518 --> 00:46:11.817
vorher und nachher macht und eigentlich nicht

00:46:11.817 --> 00:46:16.118
First Returns und Airbus Yielded und dann was da so passiert, das war schwer zu verstehen.

00:46:16.298 --> 00:46:19.438
Also auch, dass die Fixtures alle immer neu gebaut werden, dann

00:46:19.438 --> 00:46:22.138
für jeden Test, Atomar und so, das war alles so ein bisschen,

00:46:23.638 --> 00:46:27.778
ja, das hat ein bisschen gebraucht, würde ich sagen. Gut, das sind jetzt ja alles Dinge mit

00:46:27.778 --> 00:46:31.918
diesem Caching Scope und Yield und Teardown und so, das kommt ja dann erst mal

00:46:31.918 --> 00:46:36.018
obendrauf auf das Grundkonzept. Ja, ja. Also um Fixtures an sich

00:46:36.018 --> 00:46:39.998
erst mal zu verstehen, kann man das, glaube ich, das meiste davon weglassen. Ja, ich glaube, meistens fällt man

00:46:39.998 --> 00:46:41.837
halt irgendwie direkt rüber und die machen halt dann

00:46:41.837 --> 00:46:43.738
irgendwelche Dinge, die man nicht erwartet und da kann man sich

00:46:43.738 --> 00:46:45.298
also schon ein bisschen mit in den Fuß schießen.

00:46:45.857 --> 00:46:47.638
Also ich würde auch empfehlen, also nicht am Anfang

00:46:47.638 --> 00:46:49.738
zu viel komplexe Tests darzuschreiben

00:46:49.738 --> 00:46:51.877
und vielleicht erstmal ein klein oder ein, zwei kleine

00:46:51.877 --> 00:46:54.058
und halt einfache Objekte einzugeben,

00:46:54.278 --> 00:46:55.398
wo man halt guckt, wie die

00:46:55.398 --> 00:46:57.558
zusammenhängen zum Beispiel oder was die tun.

00:47:01.698 --> 00:47:03.778
Was ich halt hinterher wirklich schwierig finde, ist dann

00:47:03.778 --> 00:47:05.778
Objekte zu erzeugen oder viele Objekte oder

00:47:05.778 --> 00:47:07.857
halt dann, man kann, was halt auch

00:47:07.857 --> 00:47:09.518
sehr schön ist, was Florian auch gut gezeigt hat,

00:47:09.518 --> 00:47:11.898
Parametrisierung mit beispielsweise

00:47:11.898 --> 00:47:13.178
Data Clusters oder sowas,

00:47:13.998 --> 00:47:15.317
dass man halt tatsächlich eine

00:47:15.317 --> 00:47:17.798
Plethora, 100 verschiedene

00:47:17.798 --> 00:47:19.978
Dinge erstellt, automatisiert erzeugt

00:47:19.978 --> 00:47:21.798
an Tests, die die verschiedenen

00:47:21.798 --> 00:47:23.837
Edge Cases seiner Fälle dann halt auch

00:47:23.837 --> 00:47:25.718
beinhalten und man halt dann die Logik

00:47:25.718 --> 00:47:27.038
testen kann, ob sie da noch reißt.

00:47:27.978 --> 00:47:29.918
Ohne jetzt direkt auf Hypothesis zu gehen,

00:47:30.038 --> 00:47:31.738
Hypothesis testet nochmal, also mit

00:47:31.738 --> 00:47:33.758
zufälligen Fixtures, wenn ich das richtig verstehe,

00:47:33.837 --> 00:47:35.518
oder Zufallswerten für

00:47:35.518 --> 00:47:37.098
Dinge in den Fixtures.

00:47:37.098 --> 00:47:39.418
Ja, vielleicht noch kurz zur

00:47:39.418 --> 00:47:41.357
Parametrisierung. Wenn ich mir

00:47:41.357 --> 00:47:43.298
jetzt Python anschauen würde und mal so die erste

00:47:43.298 --> 00:47:44.618
Testfunktion geschrieben habe,

00:47:45.678 --> 00:47:47.398
wäre das sicherlich so eines der ersten

00:47:47.398 --> 00:47:48.938
Dinge, das ich anschauen würde.

00:47:49.278 --> 00:47:51.317
Ist auch eines der ersten Dinge dann in meinem

00:47:51.317 --> 00:47:51.718
Training.

00:47:53.278 --> 00:47:55.518
Weil das, finde ich, es halt echt einfach

00:47:55.518 --> 00:47:57.538
macht, ziemlich viel abzudecken.

00:47:58.278 --> 00:47:59.458
Wenn man jetzt irgendeine Funktion

00:47:59.458 --> 00:48:01.498
testet, um halt eben nicht einen Input

00:48:01.498 --> 00:48:03.198
und einen Output nur zu testen,

00:48:03.898 --> 00:48:05.538
jetzt mal bei irgendeiner

00:48:05.538 --> 00:48:08.018
langweiligen Utility-Funktionen.

00:48:08.118 --> 00:48:09.978
Ich habe bei mir zum Beispiel so ein Format

00:48:09.978 --> 00:48:11.178
Seconds, wo ich einfach

00:48:11.178 --> 00:48:13.658
Sekunden übergebe und das dann schön

00:48:13.658 --> 00:48:16.018
formatiere in halt Stunden, Minuten, Sekunden

00:48:16.018 --> 00:48:16.718
beispielsweise.

00:48:17.898 --> 00:48:19.738
Oder hast du auch eine Seite übrigens,

00:48:19.898 --> 00:48:21.618
kurzer Exkurs, fstring irgendwie

00:48:21.618 --> 00:48:22.357
Docs, kann das sein?

00:48:23.138 --> 00:48:24.337
fstring.help, genau.

00:48:24.337 --> 00:48:26.337
Oh ja, die habe ich auch schon oft.

00:48:27.298 --> 00:48:27.938
Ja, ein guter Punkt.

00:48:28.238 --> 00:48:29.298
Eine Webseite von mir.

00:48:30.738 --> 00:48:32.377
Habe ich mal irgendwo an der PyCon

00:48:32.377 --> 00:48:34.238
Germany, ich wollte es schon seit Jahren

00:48:34.238 --> 00:48:36.518
machen und dann kamen da die Lightning Talks

00:48:36.518 --> 00:48:37.898
unter PyCon Germany und dann

00:48:37.898 --> 00:48:40.178
ab und vor den Lightning Talks, habe ich die noch kurz

00:48:40.178 --> 00:48:42.238
gemacht, um sie dann

00:48:42.238 --> 00:48:43.857
eben da vorstellen zu können.

00:48:44.118 --> 00:48:45.578
Ja, aber das ist echt super, weil sowas hat echt gefehlt,

00:48:45.658 --> 00:48:47.078
das ist echt gut.

00:48:48.317 --> 00:48:48.898
Hör ich gerne.

00:48:49.918 --> 00:48:51.018
Ja, Parameterization

00:48:51.018 --> 00:48:53.857
macht es einem eben einfach,

00:48:54.258 --> 00:48:55.958
um dann aus einer Testfunktion, die nur

00:48:55.958 --> 00:48:57.218
ein Wert testet,

00:48:58.058 --> 00:48:59.998
den so zu erweitern, um zum Beispiel

00:48:59.998 --> 00:49:02.098
10 oder 20 Werte zu

00:49:02.098 --> 00:49:03.998
testen, ohne 10 oder

00:49:03.998 --> 00:49:17.655
120 separate Funktionen daf schreiben zu m Und das ist sowas das vermisse ich dann sehr schnell in anderen Testframeworks meistens geht das schon irgendwie aber halt mit einer aufwendigeren Syntax als in Python oder als mit PyTest

00:49:17.655 --> 00:49:19.535
Ja

00:49:19.535 --> 00:49:23.115
genau, also PyTest Parameterize

00:49:23.115 --> 00:49:24.815
ist halt irgendwie dann der Dekorator, den man

00:49:24.815 --> 00:49:27.275
da verwendet, den benutze ich auch ständig

00:49:27.275 --> 00:49:28.595
aber es gibt auch noch

00:49:28.595 --> 00:49:30.415
eine andere Möglichkeit, man kann auch irgendwie

00:49:30.415 --> 00:49:32.855
Fixtures, die können irgendwie

00:49:32.855 --> 00:49:34.915
mehrere Dinge zurückgeben und dann

00:49:34.915 --> 00:49:36.375
werden auch, wird das

00:49:36.375 --> 00:49:38.635
werden die auch quasi sozusagen wie unterschiedliche

00:49:38.635 --> 00:49:40.535
Parameter, also wird der Test auf mehrfach

00:49:40.535 --> 00:49:41.435
ausgeführt mit den unterschiedlichen Parametern.

00:49:41.435 --> 00:49:44.515
Du meinst, wenn du mehrfach hintereinander yieldest, weil das mit dem ersten Aufbruch

00:49:44.515 --> 00:49:46.115
mal zweiten Aufbruch, dritten Aufbruch passiert?

00:49:46.115 --> 00:49:48.695
Nee, ich weiß es gar nicht mehr genau.

00:49:49.955 --> 00:49:50.595
Nee, du kannst

00:49:50.595 --> 00:49:52.195
im Fixture Decorator

00:49:52.195 --> 00:49:54.315
kannst du dann nochmal eine Liste von Params

00:49:54.315 --> 00:49:54.795
angeben.

00:49:56.335 --> 00:49:58.455
Und dann wird jeder Test, der die Fixture nutzt,

00:49:58.535 --> 00:49:59.655
wird halt mehrmals ausgeführt.

00:50:00.275 --> 00:50:00.855
Genau, genau.

00:50:00.955 --> 00:50:03.995
Wenn du irgendwie mehrere Backends hast

00:50:03.995 --> 00:50:05.975
oder mehrere Implementationen, die sich

00:50:05.975 --> 00:50:34.695
Ja, das ist halt ganz nützlich,

00:50:34.695 --> 00:50:36.775
gerade für das Teardown. Also die Frage ist halt,

00:50:37.055 --> 00:50:38.735
nutzt ihr irgendwie sowas wie Factories

00:50:38.735 --> 00:50:40.495
oder sowas? Also, dass man dann

00:50:40.495 --> 00:50:42.655
Objekte zusammenbaut, ja,

00:50:42.715 --> 00:50:44.655
man könnte ja eine Factory schreiben, um

00:50:44.655 --> 00:50:46.735
einen User zu erzeugen, was da alles rein muss, der dann

00:50:46.735 --> 00:50:48.595
zum Beispiel Defaults enthält. Da habe ich

00:50:48.595 --> 00:50:50.795
einen schönen Blog-Eintrag zugesehen,

00:50:50.895 --> 00:50:52.775
wie man das ordentlich

00:50:52.775 --> 00:50:54.375
machen soll, irgendwie.

00:50:54.615 --> 00:50:56.475
Es gab zwischendurch mal so eine Bibliothek, die

00:50:56.475 --> 00:50:58.715
hieß Factory Boy, die habe ich dann

00:50:58.715 --> 00:51:00.975
irgendwann wieder rausgeschmissen, die dann solche Sachen machte,

00:51:01.655 --> 00:51:02.695
aber nicht so wie das,

00:51:03.775 --> 00:51:04.575
wie ich das schön fand,

00:51:04.695 --> 00:51:06.795
also mittlerweile glaube ich, man nimmt halt irgendwie

00:51:06.795 --> 00:51:09.075
dann einzelne Dinge von Faker vielleicht,

00:51:09.495 --> 00:51:10.695
um sich Zufallssachen auch

00:51:10.695 --> 00:51:11.395
erstellen zu lassen.

00:51:12.515 --> 00:51:14.155
Ja, denke ich, ist aber ein anderes Problem.

00:51:15.155 --> 00:51:16.635
Und dann baut halt dann diese

00:51:16.635 --> 00:51:18.695
Funktion halt dann zufällig Objekte zusammen

00:51:18.695 --> 00:51:20.635
und dann könnte man zum Beispiel sagen, parametrisiere

00:51:20.635 --> 00:51:22.595
das mal für, keine Ahnung, 10 oder 20

00:51:22.595 --> 00:51:24.475
zufällige Nutzer

00:51:24.475 --> 00:51:26.835
aus so einer

00:51:26.835 --> 00:51:28.475
Factory heraus und benutze die halt einfach mal.

00:51:28.735 --> 00:51:30.615
Was die Tests natürlich nicht ganz

00:51:30.615 --> 00:51:32.655
so reproduzierbar macht vielleicht,

00:51:32.655 --> 00:51:33.795
aber vielleicht dann halt auch doch.

00:51:33.795 --> 00:51:36.055
je nachdem, wie man das halt festgelegt hat.

00:51:36.215 --> 00:51:37.655
Das wäre halt dann interessant,

00:51:38.535 --> 00:51:40.315
wie oft man das laufen lässt, um zu gucken,

00:51:40.835 --> 00:51:41.895
das Ergebnis immer gleich,

00:51:42.515 --> 00:51:44.055
ob man einen Spezialfall, wo es nicht passt,

00:51:45.035 --> 00:51:46.235
hat man einen Fehler in der Factory gebaut,

00:51:46.995 --> 00:51:48.275
nimmt man vielleicht sogar die Factory

00:51:48.275 --> 00:51:50.475
später auch für den eigentlichen Programmcode,

00:51:50.535 --> 00:51:52.395
um dann wirklich was Neues zu erzeugen?

00:51:53.995 --> 00:51:54.515
Ja, ich

00:51:54.515 --> 00:51:56.915
weiß jetzt nicht, wie sinnvoll ich das halte.

00:51:56.915 --> 00:51:59.075
Also, so gezielt

00:51:59.075 --> 00:52:01.175
sowas zu nutzen, wäre jetzt auch eine Hypothesis,

00:52:01.315 --> 00:52:02.975
was wir sicherlich noch

00:52:02.975 --> 00:52:03.655
sprechen.

00:52:03.975 --> 00:52:06.035
Also Jochen, soll ich auch kurz gestören?

00:52:06.995 --> 00:52:08.295
Ja, ich habe so etwas

00:52:08.295 --> 00:52:10.795
Factory Boy und sowas früher mal verwendet,

00:52:10.955 --> 00:52:12.555
aber ich mache das eigentlich inzwischen nicht mehr.

00:52:13.715 --> 00:52:15.035
Ich habe...

00:52:15.035 --> 00:52:17.255
Mach doch kurz fertig.

00:52:17.255 --> 00:52:19.115
Ja, also einfach

00:52:19.115 --> 00:52:21.075
deswegen, weil ich finde, das macht einfach zu viel

00:52:21.075 --> 00:52:22.495
Magie mit irgendwelchen...

00:52:22.495 --> 00:52:24.815
Du hast ja dann auch wieder so Dekoratoren für die

00:52:24.815 --> 00:52:26.535
Python...

00:52:26.535 --> 00:52:29.175
Und ich weiß gar nicht, ob diese Magie so viel

00:52:29.175 --> 00:52:31.215
bringt. Also das ist immer so. Das Verhältnis von

00:52:31.215 --> 00:52:33.035
wie viel Magie ist da und wie schwer ist das zu verstehen

00:52:33.035 --> 00:52:35.235
im Verhältnis zu wie viel Nutzen bringt, das ist für mich

00:52:35.235 --> 00:52:36.255
jetzt inzwischen nicht mehr so

00:52:36.255 --> 00:52:39.295
also diese Relation ist nicht so, dass ich

00:52:39.295 --> 00:52:41.295
sagen würde, das ist total sinnvoll, das zu verwenden, sondern ich denke

00:52:41.295 --> 00:52:42.635
mir eher so, inzwischen

00:52:42.635 --> 00:52:44.795
ist halt auch irgendwie

00:52:44.795 --> 00:52:47.315
wenn man halt ordentliche Funktionen, die solche Daten

00:52:47.315 --> 00:52:49.215
generieren, schreibt, halt auch mit entsprechend

00:52:49.215 --> 00:52:51.095
benannten, weiß ich nicht,

00:52:51.175 --> 00:52:53.175
Keyword-Only-Argumenten oder so, dann ist das

00:52:53.175 --> 00:52:54.315
eigentlich mal die bessere Variante

00:52:54.315 --> 00:52:57.295
und ich habe auch oft jetzt in Projekten

00:52:57.295 --> 00:52:59.115
inzwischen sowas wie so ein

00:52:59.115 --> 00:53:01.255
DevData-Modul oder so, wo ich mir halt

00:53:01.255 --> 00:53:03.255
Daten für bestimmte, und das

00:53:03.255 --> 00:53:05.315
brauche ich halt nicht nur für Tests, sondern halt auch einfach

00:53:05.315 --> 00:53:07.275
um Applikationen gezielt in bestimmte

00:53:07.275 --> 00:53:09.255
Zustände versetzen zu können, um halt

00:53:09.255 --> 00:53:10.755
zum Beispiel irgendwas zeigen zu können oder so,

00:53:11.255 --> 00:53:13.315
dass ich halt mir für diese Fälle, die ich dann

00:53:13.315 --> 00:53:15.155
habe, halt immer irgendwie sowas schreibe,

00:53:15.455 --> 00:53:17.135
wo ich dann einfach nur eine Funktion aufrufe,

00:53:17.635 --> 00:53:19.035
wo ich sagen kann, okay, versetz meinen

00:53:19.035 --> 00:53:21.155
Applikationszustand mal in dieses, also

00:53:21.155 --> 00:53:23.215
meine Applikation mal in diesen Zustand, wenn ich irgendwas

00:53:23.215 --> 00:53:25.255
demonstrieren kann, und das kann ich dann halt auch

00:53:25.255 --> 00:53:26.455
für Tests verwenden. Das heißt,

00:53:26.455 --> 00:53:32.275
sozusagen. Dieses Generieren von diesen Daten oder so ist schon in meiner Applikation drin und das benutze ich dann in den Tests halt auch.

00:53:32.775 --> 00:53:35.455
Und ich benutze eigentlich sowas wie Factory-Buy und sowas gar nicht mehr.

00:53:35.815 --> 00:53:38.455
Ich habe gerade den Blog-Artikel gefunden, den ich meinte.

00:53:38.535 --> 00:53:41.355
Hast du den von Luke Plant? Luke Plant, genau. Ja, okay. Ja, der ist gut.

00:53:41.575 --> 00:53:44.415
Ja, und so ähnlich habe ich das auch dann, glaube ich, versucht umzubauen.

00:53:45.755 --> 00:53:49.175
Ja, weil der macht dann quasi ja auch so ein... Das ist ja halt quasi das, was ich meinte, ne?

00:53:49.215 --> 00:53:51.455
Default-Keyword-Arguments mit vielleicht einem Faker dazu.

00:53:52.035 --> 00:53:54.315
Und dann hast du halt eine parametrisierbare...

00:53:54.315 --> 00:53:56.075
Ja, und Faker ist halt nochmal eine andere

00:53:56.075 --> 00:53:58.095
Geschichte, wo es einfach darum geht, dass man halt

00:53:58.095 --> 00:54:00.235
wenn man jetzt, dass man sich nicht als Faker

00:54:00.235 --> 00:54:02.355
selber ausdenken muss, dass man so plausible Daten hat

00:54:02.355 --> 00:54:03.515
Okay, ja

00:54:03.515 --> 00:54:06.095
Du kannst Faker auch in Seed mitgeben zum Beispiel

00:54:06.095 --> 00:54:06.895
Ja, und dann kannst du halt

00:54:06.895 --> 00:54:07.995
Genau

00:54:07.995 --> 00:54:11.735
Ja, genau

00:54:11.735 --> 00:54:13.855
Ja, vielleicht

00:54:13.855 --> 00:54:16.475
wäre das jetzt gerade der Punkt, um noch was zur Hypothesis

00:54:16.475 --> 00:54:17.255
zu sagen

00:54:17.255 --> 00:54:18.415
Klingt gut

00:54:18.415 --> 00:54:22.275
Das ist ein Projekt, was erstmal nicht viel mit PyTest

00:54:22.275 --> 00:54:24.195
zu tun hat, aber sich halt doch

00:54:24.195 --> 00:54:25.635
gut in PyTest integriert

00:54:25.635 --> 00:54:28.015
zu sogenannten

00:54:28.015 --> 00:54:29.855
Property-Based Testing.

00:54:30.795 --> 00:54:31.915
Man kann sich das so ein bisschen wie

00:54:31.915 --> 00:54:34.215
ein Fuzzer vorstellen, was also

00:54:34.215 --> 00:54:35.755
Zufallsdaten generiert.

00:54:36.875 --> 00:54:38.475
Ja, man kann mir zwar sagen, gib mir irgendeinen

00:54:38.475 --> 00:54:39.715
Integer und dann nimmt der

00:54:39.715 --> 00:54:41.335
alle, die er finden kann.

00:54:42.075 --> 00:54:44.395
Ja, jetzt nicht alle. Ich glaube, standardmäßig führt es dann halt

00:54:44.395 --> 00:54:46.615
200 Mal oder so die Testfunktion aus.

00:54:47.255 --> 00:54:48.195
Also nicht so

00:54:48.195 --> 00:54:50.495
viel. Und alle Integer

00:54:50.495 --> 00:54:51.655
werden eh schwierig.

00:54:51.655 --> 00:54:55.595
Also Herr Patos, das kann auch sehr langsam werden

00:54:55.595 --> 00:55:03.355
Aber halt mit der Idee, dass man sich eben so Strategien zusammenbauen kann

00:55:03.355 --> 00:55:07.575
Also auch sagen kann, ich will jetzt gerne irgendwie Dictionaries

00:55:07.575 --> 00:55:11.375
und die Keys sollen Strings sein, aber nur mit ASCII-Zeichen

00:55:11.375 --> 00:55:15.135
und die Values sollen dann irgendwie Listen sein

00:55:15.135 --> 00:55:18.995
und die Elemente darin sollen dann irgendwie das und das sein

00:55:18.995 --> 00:55:21.395
oder auch passend

00:55:21.395 --> 00:55:23.255
beispielsweise auch auf ein Django-Model

00:55:23.255 --> 00:55:23.735
und sowas.

00:55:25.435 --> 00:55:27.235
Und dann kann man sich mit diesen Strategien

00:55:27.235 --> 00:55:29.195
halt ein bisschen gezielter Daten

00:55:29.195 --> 00:55:30.655
generieren

00:55:30.655 --> 00:55:33.415
und dann halt eben auf seine Funktionen loslassen.

00:55:34.535 --> 00:55:35.295
Und gerade bei

00:55:35.295 --> 00:55:37.275
so bestimmten Arten von Code,

00:55:37.395 --> 00:55:38.795
gerade wenn es darum geht, irgendwo

00:55:38.795 --> 00:55:41.155
Dinge aus einem String zu parsen oder so,

00:55:42.395 --> 00:55:43.495
ist das relativ einfach,

00:55:43.595 --> 00:55:44.775
sich da so eine Strategie

00:55:44.775 --> 00:55:46.875
auszudenken oder auch einfach zu sagen,

00:55:47.015 --> 00:55:48.835
schmeiß da bitte mal Zufallsdaten hin.

00:55:48.995 --> 00:55:51.115
Einfach zufällige Strings

00:55:51.115 --> 00:55:53.295
und dann, wenn es geht,

00:55:53.455 --> 00:55:55.235
noch irgendwelche Invariants

00:55:55.235 --> 00:55:57.315
zu testen, also Dinge, die immer wahr sein

00:55:57.315 --> 00:55:59.155
sollen, egal was der Input ist

00:55:59.155 --> 00:56:00.695
Also wenn man irgendwo so

00:56:00.695 --> 00:56:03.235
ein Compress und ein Decompress hat,

00:56:03.335 --> 00:56:05.215
dann kann man das einmal durchlassen, einmal sagen

00:56:05.215 --> 00:56:07.195
Compress, einmal Decompress

00:56:07.195 --> 00:56:09.055
und dann soll das gleiche wieder rauskommen

00:56:09.055 --> 00:56:11.895
Decrypt, Encrypt

00:56:11.895 --> 00:56:13.555
Encode, Decode, alles so diese

00:56:13.555 --> 00:56:15.675
Paare, die sich halt umkehren

00:56:15.675 --> 00:56:16.235
sollten

00:56:16.235 --> 00:56:18.235
Ja, da merkt man ja relativ schnell, ob man

00:56:18.235 --> 00:56:19.595
irgendeinen Hex halt wo, ups

00:56:19.595 --> 00:56:22.675
Genau, dann lässt man das mal laufen

00:56:22.675 --> 00:56:24.695
und dann ist die Chance

00:56:24.695 --> 00:56:26.535
relativ groß, dass Hypothesis halt

00:56:26.535 --> 00:56:28.595
mit irgendeinem komischen Corner Case kommt

00:56:28.595 --> 00:56:30.055
den man echt nicht bedacht hatte

00:56:30.055 --> 00:56:32.255
Ja, das ist mir auch

00:56:32.255 --> 00:56:33.875
schon öfters auf die Füße gefallen, hat mir dann

00:56:33.875 --> 00:56:36.055
die Augen geöffnet, warum zwischendurch irgendwas

00:56:36.055 --> 00:56:37.855
komisches passierte, was man irgendwie nicht erwartet hätte

00:56:37.855 --> 00:56:40.595
Muss man doch mal drüber nachdenken, was mache ich denn da überhaupt eigentlich

00:56:41.235 --> 00:56:44.195
Wenn was kaputt ist, ist das schon immer so ein bisschen

00:56:44.195 --> 00:56:45.975
Ja, ich glaube, das muss ich mir mal

00:56:45.975 --> 00:56:52.595
Ich habe das schon mal ausprobiert, aber ich habe es noch nicht wirklich häufig in den Dingen verwendet, die ich so mache.

00:56:54.535 --> 00:56:59.615
Also ich hatte das Gefühl tatsächlich, dass es so ein bisschen langsam ist, aber dann kann man das ja auch aufzeichnen, glaube ich.

00:57:01.075 --> 00:57:10.095
Ja, die Idee davon ist eigentlich, dass es eben nicht langsam ist, dass man es halt als Teil seinen normalen Tests laufen lassen kann.

00:57:10.095 --> 00:57:14.095
Aber für mich war das immer so ein Punkt, wo ich dann angefangen habe, tatsächlich die Sachen einzuschränken.

00:57:14.095 --> 00:57:15.735
einzuschränken. Also wenn ich halt gemerkt habe, okay,

00:57:15.915 --> 00:57:17.795
das ist langsam halt eine Unit

00:57:17.795 --> 00:57:20.055
dann laufen lassen mit maximal möglichen

00:57:20.055 --> 00:57:21.995
Parametern und dann war es

00:57:21.995 --> 00:57:23.995
halt natürlich langsam, hat der Test dann vielleicht auch mal fast eine Minute

00:57:23.995 --> 00:57:25.995
gedauert oder so, aber dann habe ich halt tatsächlich

00:57:25.995 --> 00:57:28.055
X-Cases gefunden, die ich rausschmeißen konnte und konnte

00:57:28.055 --> 00:57:29.795
dann mir sinnvoll überlegen, okay,

00:57:30.215 --> 00:57:32.015
der Eingabewert ist jetzt vielleicht doch nur maximal

00:57:32.015 --> 00:57:33.255
siebenstellig oder so

00:57:33.255 --> 00:57:35.595
und nicht noch mehr. Und dann wurde

00:57:35.595 --> 00:57:37.775
der Test natürlich dann viel schneller und dann habe ich

00:57:37.775 --> 00:57:39.875
gesagt, sorry, aber mehr ist jetzt hier einfach nicht

00:57:39.875 --> 00:57:41.915
erlaubt und das hat direkt

00:57:41.915 --> 00:57:43.575
mit abgefangen. Und so,

00:57:43.575 --> 00:57:50.355
Das war, glaube ich, an der Stelle eine gute Strategie, um mal so ein bisschen die Grenzen zu gucken, was überhaupt an I.O. da sinnvoll ist auch.

00:57:50.775 --> 00:57:53.875
Sondern so eine Sanitization zu machen an Teilstellen oder sowas Gutes.

00:57:55.075 --> 00:58:04.195
Ja, am Schluss muss halt auch der Code, der dann irgendwas testet, genug schnell sein, dass man den 200 Mal laufen lassen kann und es dann auch trotzdem nur idealerweise in Bruchteilen eine Sekunde geht.

00:58:05.175 --> 00:58:06.795
Das ist nicht immer der Fall.

00:58:08.335 --> 00:58:08.575
Ja.

00:58:09.595 --> 00:58:12.195
Ja, das ist auch so ein interessantes Thema, finde ich.

00:58:12.195 --> 00:58:42.175
und PyTest.

00:58:42.195 --> 00:58:43.035
der Testmarker.

00:58:45.095 --> 00:58:45.955
Man könnte ja

00:58:45.955 --> 00:58:48.055
Dinge, könnte alle Tests, die nicht so schnell

00:58:48.055 --> 00:58:49.915
gehen, als langsam markieren oder sowas und die halt nicht

00:58:49.915 --> 00:58:51.835
immer parallel laufen lassen, sondern nur dann, wenn man es

00:58:51.835 --> 00:58:53.835
explizit möchte oder in der Pipeline oder so

00:58:53.835 --> 00:58:55.835
und nur die schnellen

00:58:55.835 --> 00:58:58.095
standardmäßig nebenbei von der IDE prüfen lassen.

00:58:59.835 --> 00:59:00.135
Ja,

00:59:00.275 --> 00:59:02.015
kommt halt auch ein bisschen davon, wie viele Tests

00:59:02.015 --> 00:59:02.635
man da hat.

00:59:04.195 --> 00:59:06.035
Also wenn ich mir jetzt PyTest selbst anschaue,

00:59:06.115 --> 00:59:08.015
wenn ich mir QBrowser anschaue, dann ist

00:59:08.015 --> 00:59:09.215
das irgendwas Vierstelliges

00:59:09.215 --> 00:59:11.975
und dann wird es

00:59:41.975 --> 01:00:11.955
und wie man das testen kann.

01:00:11.975 --> 01:00:13.915
gesehen, dass das jemand erfolgreich gemacht hat und

01:00:13.915 --> 01:00:15.935
dass es in einem größeren Projekt dann wirklich gut funktioniert hat,

01:00:15.995 --> 01:00:17.955
weil, ja, das könnte

01:00:17.955 --> 01:00:18.515
ein Weg sein.

01:00:19.815 --> 01:00:22.055
Ja, ich bin jetzt nicht so

01:00:22.055 --> 01:00:23.915
viel im Web-Umfeld

01:00:23.915 --> 01:00:26.035
unterwegs. Ich habe ein Projekt, was ich

01:00:26.035 --> 01:00:28.335
maintaine, Studentenportal.

01:00:28.955 --> 01:00:29.815
So ein

01:00:29.815 --> 01:00:32.095
Portal für Lernhilfen

01:00:32.095 --> 01:00:33.915
und Zitate

01:00:33.915 --> 01:00:35.935
von Dozierenden und sowas, halt von

01:00:35.935 --> 01:00:36.995
Studierenden für Studierende.

01:00:38.355 --> 01:00:40.155
Und das ist eine Django-Applikation

01:00:40.155 --> 01:00:41.715
und da hatten wir das mal diskutiert.

01:00:41.975 --> 01:00:43.715
und sind dann zum Schluss

01:00:43.715 --> 01:00:45.415
gekommen, dass wir einfach zu viele

01:00:45.415 --> 01:00:48.095
datenbankspezifische Kleinigkeiten

01:00:48.095 --> 01:00:49.735
haben. Also

01:00:49.735 --> 01:00:52.175
spätestens, wo du halt irgendeine Fulltext-Suche

01:00:52.175 --> 01:00:54.035
verwendest und das halt dann so

01:00:54.035 --> 01:00:56.015
PostgreSQL Fulltext-Search

01:00:56.015 --> 01:00:58.055
nutzt, dann kannst du

01:00:58.055 --> 01:00:59.275
das nicht mal so auf die Schnelle

01:00:59.275 --> 01:01:02.235
ersetzen. Oder wenn du es kannst,

01:01:02.435 --> 01:01:03.955
läufst du also in die Gefahr, dass die

01:01:03.955 --> 01:01:05.855
Tester dann überhaupt nicht mehr das testen,

01:01:05.915 --> 01:01:07.375
was eigentlich in der Realität läuft.

01:01:07.475 --> 01:01:09.715
Ja, klar. Das ist das Problem.

01:01:09.715 --> 01:01:09.895
Ja.

01:01:11.975 --> 01:01:13.875
Ja, ich finde

01:01:13.875 --> 01:01:15.695
das auch schwierig. Also so Datenbank-Sachen testen,

01:01:15.975 --> 01:01:17.795
muss man sich oft darauf verlassen, dass das irgendwie

01:01:17.795 --> 01:01:19.755
geht und dass das andere

01:01:19.755 --> 01:01:21.095
Menschen schon getestet haben.

01:01:22.455 --> 01:01:23.995
Und ja, das fällt dann halt auch

01:01:23.995 --> 01:01:26.015
tatsächlich oft runter, weil das so ein bisschen

01:01:26.015 --> 01:01:27.935
nervig

01:01:27.935 --> 01:01:29.855
sein kann. Also, ne, weil

01:01:29.855 --> 01:01:31.795
das halt so langsam wird dann im Entwickeln und

01:01:31.795 --> 01:01:33.855
wenn man das alles aufsetzen muss, dann muss ja auch die Datenbank

01:01:33.855 --> 01:01:35.875
laufen. Also ganz ehrlich, also alleine Datenbank

01:01:35.875 --> 01:01:37.615
laufen zu lassen auf einem Dev-Rechner ist manchmal

01:01:37.615 --> 01:01:39.635
schon eine Herausforderung, je nachdem, was man

01:01:39.635 --> 01:01:40.255
alles aufhaben muss.

01:01:40.255 --> 01:01:41.835
und... Ja gut, muss ja,

01:01:42.035 --> 01:01:43.955
dann glaubst du halt angucken können auf dem Testsystem,

01:01:44.195 --> 01:01:46.075
was die Daten auch schon für... Ja, aber

01:01:46.075 --> 01:01:47.995
wenn dann halt Menschen drei oder vier oder fünf

01:01:47.995 --> 01:01:49.635
verschiedene Projekte gleich machen müssen,

01:01:49.635 --> 01:01:52.235
und dann haben die nur irgendwie einen Rechner mit 80 Gramm

01:01:52.235 --> 01:01:53.955
oder sowas, müssen dann irgendwie aber einen Docker drauf haben,

01:01:54.035 --> 01:01:56.075
und dann müssen die Container aber irgendwie alle gleichzeitig anleihen, weil die schnell

01:01:56.075 --> 01:01:57.995
wechseln müssen, dann macht es dann bei fünf

01:01:57.995 --> 01:01:59.975
verschiedenen Datenmarken schon bumm, dann musst du dann irgendwie gucken, dass

01:01:59.975 --> 01:02:01.455
du vielleicht eine hast, die dann irgendwie weg abstrahiert,

01:02:01.875 --> 01:02:04.215
wo dann aber auch die Klientel stimmen, und dann musst du, wenn du eine abreißt,

01:02:04.235 --> 01:02:06.055
nicht alle abreißen, weil du den Container nicht einfach kaputt machen kannst,

01:02:06.095 --> 01:02:07.755
die Volumens und dieses was, und ja.

01:02:08.695 --> 01:02:08.875
Ja.

01:02:08.875 --> 01:02:11.795
Wir werden schnell schon wieder mit dem Kopf gegen die Wand

01:02:11.795 --> 01:02:14.475
Softwareentwicklung

01:02:14.475 --> 01:02:16.595
mit 8 GB RAM

01:02:16.595 --> 01:02:18.095
finde ich halt auch so ein bisschen kritisch

01:02:18.095 --> 01:02:20.615
Ja, ist eine Katastrophe, muss ich sowas nicht tun

01:02:20.615 --> 01:02:22.375
Also, Apple

01:02:22.375 --> 01:02:23.935
macht das ja, dass sie ihre neuen

01:02:23.935 --> 01:02:26.315
MacBook Pros haben, im Standardmodell

01:02:26.315 --> 01:02:27.035
mit 8 GB

01:02:27.035 --> 01:02:29.375
für 1000 noch was Euro

01:02:29.375 --> 01:02:31.215
Ja, das ist eine Gemeinheit, aber ja

01:02:31.215 --> 01:02:35.315
Aber ja, ich meine, ich mit

01:02:35.315 --> 01:02:37.895
Qt-Browser, vielleicht soll ich da ja dann auch

01:02:37.895 --> 01:02:39.555
und wollen noch ein paar Worte dazu sagen.

01:02:40.975 --> 01:02:42.055
Da muss ich halt ab und zu

01:02:42.055 --> 01:02:43.795
auch Chromium kompilieren, also

01:02:43.795 --> 01:02:45.475
der Code hinter Google Chrome.

01:02:47.355 --> 01:02:47.875
Und

01:02:47.875 --> 01:02:49.795
das braucht so mit einem

01:02:49.795 --> 01:02:51.915
Developer-Build, also mit Debug-Symbolen

01:02:51.915 --> 01:02:53.815
und so, braucht das halt mal so

01:02:53.815 --> 01:02:55.435
irgendwie um die 30 GB RAM.

01:02:56.175 --> 01:02:57.895
Wow, allein das Kompilieren von dem...

01:02:58.415 --> 01:02:59.095
Okay, das...

01:02:59.095 --> 01:03:01.495
Wenn ich es halt parallel machen würde,

01:03:01.655 --> 01:03:03.415
nur mit so einem Build-Job würde es mir wahrscheinlich

01:03:03.415 --> 01:03:04.515
weniger reichen.

01:03:05.975 --> 01:03:06.655
Aber ja,

01:03:06.655 --> 01:03:10.055
Wir haben dann 32 GB tatsächlich nicht mehr ausgereicht.

01:03:11.755 --> 01:03:16.095
Ich bin jetzt auf 48, was halt das Maximale ist, was in den Laptop passt überhaupt.

01:03:16.915 --> 01:03:19.095
Weil 16, glaube ich, fix eingelötet sind.

01:03:21.115 --> 01:03:23.155
Aber das fand ich schon heftig.

01:03:23.675 --> 01:03:25.915
Also Chromium ist ein riesiges Projekt.

01:03:27.555 --> 01:03:32.275
Aber wenn es so weitergeht, das wird dann nur noch komplexer, wie es bei Software halt auch so ist.

01:03:32.855 --> 01:03:34.495
Da habe ich echt irgendwann ein Problem.

01:03:34.495 --> 01:03:36.355
Ja

01:04:04.495 --> 01:04:08.935
und schauen dann halt mal, was da zurückkommt von GitHub Actions.

01:04:11.755 --> 01:04:12.915
Dieser Test ist fehlgeschlagen.

01:04:13.035 --> 01:04:14.175
Oh, ja okay, meistens nicht.

01:04:15.115 --> 01:04:19.655
Manchmal gelingt es einem halt, das durchzukriegen, aber ja, ja okay.

01:04:20.835 --> 01:04:26.835
Was auch super ist, wenn man dann gar keine Testumgebung hat und das halt direkt durchgeht.

01:04:27.415 --> 01:04:28.575
Da war es halt auch keine Entwicklungsumgebung.

01:04:28.575 --> 01:04:31.495
Was ist das da, Codespaces oder so?

01:04:31.495 --> 01:04:33.255
und dann ist alles nur noch

01:04:33.255 --> 01:04:35.615
der Cloud. Wunderbar.

01:04:36.455 --> 01:04:37.395
Jemand anderes Problem.

01:04:37.395 --> 01:04:38.455
Jetzt lasse ich dann halt so

01:04:38.455 --> 01:04:41.635
die Tests für das, was ich gerade daran arbeite,

01:04:41.695 --> 01:04:43.535
die lasse ich lokal laufen. Aber so eine volle

01:04:43.535 --> 01:04:45.575
Testbatterie soll

01:04:45.575 --> 01:04:46.335
woanders laufen.

01:04:47.055 --> 01:04:49.395
Auch das ist vielleicht ein guter Punkt für

01:04:49.395 --> 01:04:51.615
Marx. Also um Tests zu markieren

01:04:51.615 --> 01:04:53.595
nach verschiedenen Themen oder sowas, dann kann man

01:04:53.595 --> 01:04:55.235
halt nur Tests laufen lassen für das eine

01:04:55.235 --> 01:04:55.855
Topic.

01:04:56.455 --> 01:04:59.215
Wenn du entwickelt hast, machst du das ja meistens.

01:04:59.215 --> 01:05:07.095
und Python ist ein Test, das du einfach sozusagen, entweder nur den einen Test, von dem du weißt, dass der halt betroffen ist, irgendwie laufen lässt oder halt eine Gruppe von Tests, die da außenrum sind.

01:05:07.175 --> 01:05:12.695
Ja genau, aber genau, die Frage ist halt diese Gruppe, weil wenn du die thematisch gruppierst und die vielleicht nicht an demselben Ort liegen irgendwie,

01:05:12.815 --> 01:05:20.515
wenn man halt da, man kann ja die Tests, das ist auch eine Frage der Philosophie, ob man den einen Testfahrzeichen schreibt oder an die Applikationen, an die ganzen Apps, wo die zugehören oder so.

01:05:21.135 --> 01:05:21.455
Ja.

01:05:21.455 --> 01:05:28.515
Und wenn die dann halt so distributed sind und dann willst du aber trotzdem viele verschiedene davon zusammenlaufen lassen, weil die mit der Funktionalität dann doch irgendwie zusammenhängen.

01:05:28.515 --> 01:05:31.795
Also auch da eine Frage, kann man sich über die Architektur

01:05:31.795 --> 01:05:34.235
Gedanken machen, gibt es vielleicht doch Gründe, das dann so zu machen?

01:05:35.675 --> 01:05:37.655
Und mit diesen Markern, die man da bei PyTest

01:05:37.655 --> 01:05:40.275
drüber setzen kann, dann kann man die einfach, die gruppieren recht einfach.

01:05:40.755 --> 01:05:42.495
Finde ich gar nicht so schlecht für diese Fälle.

01:05:45.115 --> 01:05:46.635
Ja, mache ich jetzt weniger.

01:05:46.635 --> 01:05:49.335
Ich habe einen Marker einfach für alle GUI-Tests.

01:05:50.175 --> 01:05:50.835
Sowas halt.

01:05:51.755 --> 01:05:55.815
Das halt, wie ich es projektübergreifend in Tests sage, die nutzen irgendwelche GUI-Dinge

01:05:55.815 --> 01:05:58.095
und testen einfach nur Python-Code.

01:05:58.515 --> 01:06:00.575
aber ansonsten, ja

01:06:00.575 --> 01:06:02.955
ich kann mir jetzt vorstellen, so bei einem

01:06:02.955 --> 01:06:05.095
Enterprise-Projekt, können auch Kunden, die

01:06:05.095 --> 01:06:06.915
das so machen, da dann wirklich so eine

01:06:06.915 --> 01:06:09.175
Use-Case-Nummer oder so noch dranhängen

01:06:09.175 --> 01:06:10.935
und dann sagen, alle Tests

01:06:10.935 --> 01:06:12.915
irgendwie zu diesem Use-Case laufen lassen

01:06:12.915 --> 01:06:15.235
aber ansonsten

01:06:15.235 --> 01:06:17.195
finde ich, reicht eigentlich diese Unterteilung

01:06:17.195 --> 01:06:19.495
in Module. Ja, also je modularer

01:06:19.495 --> 01:06:20.995
man ist oder je modulitischer man

01:06:20.995 --> 01:06:23.155
so eine Anwendung baut, dann müsste man vielleicht tatsächlich

01:06:23.155 --> 01:06:24.695
diese einzelnen Funktionalitäten so ein bisschen

01:06:24.695 --> 01:06:27.275
so ein Multilead voneinander

01:06:27.275 --> 01:06:29.835
Ich weiß nicht, also bei mir reicht auch

01:06:29.835 --> 01:06:31.515
die Trennung in Dateien

01:06:31.515 --> 01:06:33.115
eigentlich ehrlich gesagt aus.

01:06:33.275 --> 01:06:35.595
Ich habe dafür eine Marker schon

01:06:35.595 --> 01:06:36.915
verwendet, aber nicht dafür.

01:06:38.495 --> 01:06:39.955
Aber genau, das ist eine interessante

01:06:39.955 --> 01:06:41.655
Frage, was ich jetzt auch, also einfach

01:06:41.655 --> 01:06:43.995
alles Teste in einem Tests-Directory

01:06:43.995 --> 01:06:45.675
drin haben oder halt neben

01:06:45.675 --> 01:06:47.835
die Module im Code

01:06:47.835 --> 01:06:49.735
legen. Das sind ja auch zwei unterschiedliche Möglichkeiten. Ich habe beides

01:06:49.735 --> 01:06:51.575
auch schon gesehen und ich

01:06:51.575 --> 01:06:53.675
persönlich mag es lieber irgendwie das alles in einem

01:06:53.675 --> 01:06:54.875
Tests-Verzeichnis zu haben.

01:06:55.435 --> 01:06:56.655
Ich mache tatsächlich beides.

01:06:57.275 --> 01:06:59.155
Also ich habe einen Testverzeichnis, wo

01:06:59.155 --> 01:07:00.755
so die grundlegenden Sachen drin sind, wie

01:07:00.755 --> 01:07:02.975
Kernfunktionalität, die Clients,

01:07:03.115 --> 01:07:05.235
für Authentication, die Nutzer

01:07:05.235 --> 01:07:05.995
und sowas.

01:07:06.735 --> 01:07:08.775
Und der Testwarner und diese ganzen Sachen

01:07:08.775 --> 01:07:09.815
und die Hauptfixers.

01:07:10.735 --> 01:07:12.155
Auch witzig, manchmal auch

01:07:12.155 --> 01:07:14.835
meist in anderen Fixers schon. Das heißt,

01:07:14.895 --> 01:07:16.915
Fixers für Modelle lege ich mit in das Hauptverzeichnis rein,

01:07:17.415 --> 01:07:18.875
aber die Tests selber,

01:07:19.155 --> 01:07:21.055
also die einzelnen Units für Routen zum Beispiel,

01:07:21.135 --> 01:07:23.015
die sind mit in dem API-Verzeichnis

01:07:23.015 --> 01:07:23.515
zum Beispiel oder

01:07:23.515 --> 01:07:25.375
in der App

01:07:25.375 --> 01:07:26.415
von Dango oder so.

01:07:27.275 --> 01:07:39.315
Da muss man die halt importieren, einfach in den Comptest, die man halt da nutzt und dann kann man aber direkt da die Tests schreiben, wo die Anwendung quasi liegt. Man muss nicht die ganze Zeit durch das ganze Directory so hin und her traversen.

01:07:40.035 --> 01:07:40.235
Okay.

01:07:40.235 --> 01:07:42.875
und man kann halt auch

01:07:42.875 --> 01:07:44.855
Module arbeiten und die Leute wissen halt direkt, dass die

01:07:44.855 --> 01:07:46.755
Tests da dazugehören und man vergisst dann

01:07:46.755 --> 01:07:48.955
nicht, welche für welche Module, man kann halt auch immer direkt sehen,

01:07:49.315 --> 01:07:50.815
sind die Tests für die Module jetzt schon da drin oder

01:07:50.815 --> 01:07:52.095
welche Tests für die Module gibt es denn da?

01:07:52.595 --> 01:07:54.795
Manchmal finde ich, sind Tests auch sehr nützlich, so was

01:07:54.795 --> 01:07:56.535
als wie Dokumentation

01:07:56.535 --> 01:07:58.895
für den Code, wenn ich manchmal nicht mehr

01:07:58.895 --> 01:08:00.655
so genau weiß, was passiert denn da jetzt eigentlich

01:08:00.655 --> 01:08:02.875
oder was sollte da passieren, gucke ich mir den Test an und wenn der gut

01:08:02.875 --> 01:08:05.055
geschrieben ist, sagt der Test, Test ist ja die Logik,

01:08:05.175 --> 01:08:06.895
was da passieren sollte und dann lese ich

01:08:06.895 --> 01:08:08.615
den Test, ah, so war das und dann

01:08:08.615 --> 01:08:09.875
das macht viel Sinn.

01:08:10.235 --> 01:08:12.435
Das mache ich tatsächlich auch ganz oft

01:08:12.435 --> 01:08:14.495
Oft wenn ich halt irgendwo einen Bug

01:08:14.495 --> 01:08:16.535
in einem Python-Projekt finde, der sich nutzt

01:08:16.535 --> 01:08:18.275
dann versuche ich den halt mal kurz zu beheben

01:08:18.275 --> 01:08:20.515
und dann schaue ich mir

01:08:20.515 --> 01:08:22.795
oft auch mal irgendwie jetzt bei einem fremden

01:08:22.795 --> 01:08:24.495
Open-Source-Projekt erstmal die Tests

01:08:24.495 --> 01:08:26.595
ein bisschen an, um mehr ein Gefühl

01:08:26.595 --> 01:08:27.855
zu kriegen, was da passiert

01:08:27.855 --> 01:08:30.175
wenn es dann welche gibt

01:08:30.175 --> 01:08:31.935
Ja, gut

01:08:31.935 --> 01:08:34.555
Ja, das ist tatsächlich auch eine der Sachen, die

01:08:34.555 --> 01:08:35.475
oft runterfällt, ne?

01:08:37.075 --> 01:08:38.755
Ich mache das tatsächlich aber auch so

01:08:38.755 --> 01:08:40.955
wie das die PyTest-Dokumentation, glaube ich,

01:08:40.975 --> 01:08:43.195
auch empfiehlt, dass ich einfach ein Testverzeichnis

01:08:43.195 --> 01:08:44.795
habe und dann da quasi so

01:08:44.795 --> 01:08:46.055
eins zu eins das

01:08:46.055 --> 01:08:48.195
Python-Package gespiegelt.

01:08:48.855 --> 01:08:50.375
PyTest-Dokumentation

01:08:50.375 --> 01:08:52.575
ist auch noch so eine, ich fand

01:08:52.575 --> 01:08:55.055
PyTest-Dokumentation war eine der schwierigeren Dokumentationen,

01:08:55.155 --> 01:08:55.935
die ich lesen durfte.

01:08:56.995 --> 01:08:58.095
Im Laufe der,

01:08:58.675 --> 01:09:00.035
wenn er so Python kriegt.

01:09:00.075 --> 01:09:02.615
Ja gut, das ist halt auch kompliziert.

01:09:03.635 --> 01:09:04.735
Ja, aber ich habe da

01:09:04.735 --> 01:09:05.235
diesen

01:09:05.235 --> 01:09:08.375
Curse of Knowledge halt.

01:09:08.755 --> 01:09:17.355
Ich kenne das so unter diesem Begriff, dass es halt echt schwierig ist, wenn man das alles schon verinnerlicht hat, das nochmal so in den Augen eines Neulings anzuschauen.

01:09:17.355 --> 01:09:21.715
einfach, also dass man wirklich einfach verstehen kann, was denn da passiert, das ist so eine

01:09:21.715 --> 01:09:22.595
hohe Kunst, glaube ich.

01:09:23.555 --> 01:09:27.815
Und das war also bei PyTest, ich muss auch sagen, mittlerweile ist es einfacher, also

01:09:27.815 --> 01:09:30.815
die Doku zu lesen, aber manchmal ist es, hä, was wollen die denn jetzt und warum?

01:09:31.295 --> 01:09:34.555
Und dann waren auch so ganz viele Fragen offen, die haben dann ganz viel Knowledge halt auch

01:09:34.555 --> 01:09:38.135
tatsächlich vorausgesetzt, dass man sich halt irgendwo an irgendwelchen anderen Stellen

01:09:38.135 --> 01:09:42.135
so zusammenklauben musste und wo musste man dann selber finden und so und das war schon

01:09:42.135 --> 01:09:42.975
was steil.

01:09:42.975 --> 01:09:46.075
Aber ja, also

01:09:46.075 --> 01:09:48.775
noch vielleicht so eine coole Funktionalität

01:09:48.775 --> 01:09:50.655
von Python, ich glaube, es gibt noch jede Menge Plugins,

01:09:50.755 --> 01:09:52.015
die wir noch vielleicht erwähnen können.

01:09:52.735 --> 01:09:54.635
Ich würde eins gerne herausnehmen, VCR,

01:09:55.035 --> 01:09:56.715
also irgendwie so Video Recalling auch noch,

01:09:57.335 --> 01:09:58.715
das ist auch sehr cool, ja.

01:09:59.615 --> 01:10:00.455
Was macht das denn?

01:10:00.855 --> 01:10:02.475
VCR stellt quasi,

01:10:02.775 --> 01:10:04.435
wenn du jetzt eine API nutzt, zum Beispiel

01:10:04.435 --> 01:10:06.495
ein Request, zeichnet das quasi

01:10:06.495 --> 01:10:08.475
die echten Antworten auf

01:10:08.475 --> 01:10:10.315
und macht halt quasi einen echten API-Call

01:10:10.315 --> 01:10:12.335
und schreibt das Ergebnis

01:10:12.335 --> 01:10:14.315
inklusive aller Header und allem Content

01:10:14.315 --> 01:10:16.495
und so weiter in YAML-Files rein

01:10:16.495 --> 01:10:17.935
automatisch und

01:10:17.935 --> 01:10:19.935
beim nächsten Call nimmt es einfach die

01:10:19.935 --> 01:10:22.115
und tut halt so, als wäre die echte API-Antwort

01:10:22.115 --> 01:10:24.275
quasi in der File drin und dann hast

01:10:24.275 --> 01:10:26.075
du quasi die echte API-Antwort gemockt,

01:10:26.135 --> 01:10:28.255
quasi genauso, wie sie kommt und du kannst

01:10:28.255 --> 01:10:30.215
halt PyTest immer sagen, okay, zieh jetzt mal

01:10:30.215 --> 01:10:32.395
neu, also du bist gerade in einer Umgebung, wo du das ausprobieren kannst,

01:10:32.775 --> 01:10:34.355
aber du willst ja die APIs auch wegen Quotas

01:10:34.355 --> 01:10:36.155
und so weiter halt auch nicht ständig fragen, zum Beispiel

01:10:36.155 --> 01:10:38.055
oder halt auch

01:10:38.055 --> 01:10:40.235
nur selten oder halt, wenn sich was aktualisiert

01:10:40.235 --> 01:10:42.255
und kannst aber so halt dann schon gucken,

01:10:42.335 --> 01:11:12.315
und wie das funktioniert.

01:11:12.335 --> 01:11:42.315
Ja, ich weiß nicht, aber...

01:11:42.335 --> 01:12:12.315
und wie man das dann auch in Python verändern kann.

01:12:12.335 --> 01:12:14.635
einfach PyTest halt eben irgendwie zu erweitern

01:12:14.635 --> 01:12:16.535
und unter anderem auch ein eigenes

01:12:16.535 --> 01:12:18.435
Kommandozeilen-Argument zu PyTest

01:12:18.435 --> 01:12:19.195
hinzuzufügen.

01:12:20.635 --> 01:12:21.975
Und was man dann machen kann,

01:12:22.315 --> 01:12:24.295
ist theoretisch zumindest, ich habe

01:12:24.295 --> 01:12:26.035
jetzt nicht ein Projekt, wo ich das effektiv mache,

01:12:26.215 --> 01:12:26.655
tatsächlich,

01:12:28.215 --> 01:12:29.475
eine Kommandozeilen-Option,

01:12:29.935 --> 01:12:32.135
Real API oder sowas hinzuzufügen

01:12:32.135 --> 01:12:34.275
und dann halt zu sagen, wenn ich das mitgebe,

01:12:34.535 --> 01:12:36.155
laufen einmal meine Tests gegen die

01:12:36.155 --> 01:12:37.275
richtige API durch,

01:12:38.075 --> 01:12:39.275
anstatt gegen meine

01:12:39.275 --> 01:12:41.575
recordeten Antworten.

01:12:42.335 --> 01:12:44.335
Ja, das könnte man natürlich machen, ja.

01:12:46.435 --> 01:12:48.055
Dann je nach API halt sagen,

01:12:48.275 --> 01:12:50.075
das können wir nach Avnecia irgendwie

01:12:50.075 --> 01:12:52.135
wöchentlich oder monatlich oder sowas mal

01:12:52.135 --> 01:12:54.135
ausführen. Ja, also ich finde

01:12:54.135 --> 01:12:56.115
es super spannend, also das macht halt echt

01:12:56.115 --> 01:12:57.555
coole Sachen möglich.

01:12:58.295 --> 01:13:00.335
Man kann ja auch seine eigene API quasi mit aufnehmen

01:13:00.335 --> 01:13:01.795
oder sowas, wenn man das möchte und dann hat man

01:13:01.795 --> 01:13:04.275
auch schnell so Mock-Fictures da, die man halt

01:13:04.275 --> 01:13:06.115
nicht selber bauen möchte. Selbst wenn du

01:13:06.115 --> 01:13:08.015
sagst, okay, du möchtest gerne vorher das mocken, aber

01:13:08.015 --> 01:13:09.415
ich finde das schon ziemlich gut.

01:13:11.095 --> 01:13:11.495
Ja.

01:13:12.335 --> 01:13:14.315
Man kann das sogar

01:13:14.315 --> 01:13:16.275
abusen. Wenn man

01:13:16.275 --> 01:13:16.955
sich viele

01:13:16.955 --> 01:13:20.055
Zeugs abspeichern will von

01:13:20.055 --> 01:13:22.255
irgendwelchen Scrapern oder sowas, könnte man das tatsächlich

01:13:22.255 --> 01:13:24.515
einfach einsetzen, um sich die

01:13:24.515 --> 01:13:26.295
API-Calls einfach mal wegzushaken

01:13:26.295 --> 01:13:27.135
und das relativ easy.

01:13:29.735 --> 01:13:30.535
Ja, ich weiß nicht.

01:13:30.775 --> 01:13:31.435
Also genau,

01:13:32.095 --> 01:13:34.295
ich überlege gerade, was ich

01:13:34.295 --> 01:13:36.075
an Plugins normalerweise verwende.

01:13:37.155 --> 01:13:38.255
X-Test verwende ich

01:13:38.255 --> 01:13:40.155
tatsächlich irgendwie. Aber

01:13:40.155 --> 01:13:42.075
das muss man ja, wenn man irgendwie Testparallel

01:13:42.075 --> 01:13:52.373
ausf lassen m Bekommt aber noch viel mehr Zeug mit dabei Ich bin manchmal nicht so ganz sicher ob ich das alles haben will aber was ich auch oft benutze also was ich

01:13:52.373 --> 01:13:54.112
total super finde, ist PyTestMock zum Beispiel,

01:13:54.112 --> 01:13:54.552
finde ich super.

01:13:55.472 --> 01:13:58.212
Immer wenn ich Unitest-Geschichten irgendwo mache

01:13:58.212 --> 01:13:59.752
und dann türmen sich so die

01:13:59.752 --> 01:14:02.112
Patch-Dekoratoren oder ganz

01:14:02.112 --> 01:14:04.152
viele Context-Manager und dann ist PyTestMock

01:14:04.152 --> 01:14:05.913
echt total, also sehr angenehm.

01:14:06.492 --> 01:14:07.232
Was macht das?

01:14:08.092 --> 01:14:08.752
Das übernimmt,

01:14:09.272 --> 01:14:11.913
es macht das halt automatisch. Du kriegst halt

01:14:11.913 --> 01:14:13.852
Mocker, schreibst als Fixer

01:14:13.852 --> 01:14:16.072
sozusagen in deinen Test und dann

01:14:16.072 --> 01:14:17.792
rufst du halt Mocker.patch

01:14:17.792 --> 01:14:19.992
irgendwie einfach auf, musst aber

01:14:19.992 --> 01:14:21.692
da nicht den Context Manager drum rum machen

01:14:21.692 --> 01:14:23.712
oder irgendwie das Insta-Kurator verwenden

01:14:23.712 --> 01:14:26.132
und kannst das halt auch mehrfach aufrufen,

01:14:26.393 --> 01:14:27.752
ohne dass du da halt irgendwie dann eine

01:14:27.752 --> 01:14:29.192
Verschachtelung von Context Managern hast

01:14:29.192 --> 01:14:31.873
und das wird halt hinterher auch wieder

01:14:31.873 --> 01:14:33.232
alles entmockt sozusagen,

01:14:34.252 --> 01:14:35.352
ent-gepatcht,

01:14:35.492 --> 01:14:36.572
wenn der Test vorbei ist und so.

01:14:36.752 --> 01:14:39.532
Ja, du hast recht,

01:14:39.532 --> 01:14:41.492
das ist für viele Sachen ganz nett, aber ich finde es auch irgendwie

01:14:41.492 --> 01:15:11.472
und Python

01:15:11.492 --> 01:15:13.792
und wenn was schief geht, nochmal PyTest

01:15:13.792 --> 01:15:15.373
einzuhängen, dass man halt diese

01:15:15.373 --> 01:15:17.953
den schöneren Output von PyTest

01:15:17.953 --> 01:15:19.992
kriegt, der dann auch die Werte vergleicht

01:15:19.992 --> 01:15:20.453
und sowas.

01:15:22.312 --> 01:15:23.933
Aber viel mehr als das macht das

01:15:23.933 --> 01:15:24.752
Plugin eigentlich nicht.

01:15:24.953 --> 01:15:27.352
Apropos schöner Output, PyTest-Witch natürlich.

01:15:28.953 --> 01:15:29.592
Ah, okay, ja.

01:15:31.112 --> 01:15:31.873
Ja, das hier überhaupt,

01:15:32.072 --> 01:15:33.092
das hat man noch gar nicht so richtig,

01:15:33.172 --> 01:15:35.632
das ist eigentlich fast das Hauptfeature

01:15:35.632 --> 01:15:37.312
von PyTest für mich jedenfalls,

01:15:37.532 --> 01:15:39.373
dass man einfach so

01:15:39.373 --> 01:15:41.652
Assertion schreiben kann und das halt funktioniert

01:15:41.652 --> 01:15:43.433
und man halt trotzdem eine sehr schöne Ausgabe

01:15:43.433 --> 01:15:45.492
kriegt, die einem zeigt, wo ist

01:15:45.492 --> 01:15:47.032
genau was unterschiedlich und so.

01:15:48.032 --> 01:15:49.672
Das ist halt sehr, sehr angenehm.

01:15:49.732 --> 01:15:51.232
Nicht so komisch als Asserts, ich will den

01:15:51.232 --> 01:15:51.752
Camel Case.

01:15:54.512 --> 01:15:55.732
Das ist aber auch

01:15:55.732 --> 01:15:57.592
übrigens eine ordentliche Portion

01:15:57.592 --> 01:15:59.712
Magie. Ja, ich fürchte auch irgendwie, ja.

01:16:01.072 --> 01:16:01.772
Weil an sich

01:16:01.772 --> 01:16:03.732
dieses Assert Keyword von Python,

01:16:03.852 --> 01:16:05.652
das macht einfach nur einen Assertion

01:16:05.652 --> 01:16:07.572
Error, also ohne jetzt, dass man

01:16:07.572 --> 01:16:09.572
irgendwie Zugriff hat auf Infos, was

01:16:09.572 --> 01:16:10.453
da passiert ist.

01:16:11.972 --> 01:16:13.373
PyTest macht da eben

01:16:13.373 --> 01:16:14.913
sein Rewriting.

01:16:15.612 --> 01:16:16.373
Ja, durch den Dekorator.

01:16:16.373 --> 01:16:18.332
Das ist den Abstract

01:16:18.332 --> 01:16:20.472
Syntax Tree, was

01:16:20.472 --> 01:16:22.132
Python als so ein Modul generiert,

01:16:22.232 --> 01:16:23.933
intern, bevor das wirklich dann zu

01:16:23.933 --> 01:16:25.292
Python Bytecode wird.

01:16:26.132 --> 01:16:28.172
Passiert das beim Import der Testmodule

01:16:28.172 --> 01:16:29.792
irgendwie, da wird der Bytecode dann

01:16:29.792 --> 01:16:31.672
gedruckt?

01:16:32.373 --> 01:16:34.072
Nicht der Bytecode, sondern halt

01:16:34.072 --> 01:16:36.232
ein Level vorher, der Abstract Syntax Tree.

01:16:36.232 --> 01:16:39.152
Da injectet dann PyTest noch seine eigenen

01:16:39.152 --> 01:16:40.252
Calls

01:16:40.252 --> 01:16:42.913
Um da quasi einmal festzuhalten

01:16:42.913 --> 01:16:45.472
Was ist da eigentlich drin in dieser Assertion

01:16:45.472 --> 01:16:46.933
Ja

01:16:46.933 --> 01:16:51.373
Aber es sind viele Dinge

01:16:51.373 --> 01:16:52.232
Wo ich sagen muss

01:16:52.232 --> 01:16:54.453
Es ist sehr viel Magie

01:16:54.453 --> 01:16:56.953
Aber irgendwie so unterm Strich auch sehr angenehm

01:16:56.953 --> 01:16:59.232
Also hat sich irgendwo

01:16:59.232 --> 01:17:00.032
Bewehrt

01:17:00.032 --> 01:17:03.212
Entspricht diesem Pythonic ästhetischen Ansatz

01:17:03.212 --> 01:17:04.953
Irgendwie das in klarer Sprache

01:17:04.953 --> 01:17:06.232
hinzuschreiben, was das machen soll.

01:17:06.832 --> 01:17:08.552
Das Assert ist da für Tests, glaube ich.

01:17:08.893 --> 01:17:09.812
Sieht einfach schick aus.

01:17:11.032 --> 01:17:12.512
Ja, aber wäre das jetzt nicht auch schick,

01:17:12.632 --> 01:17:14.812
wenn Assert in anderen Stellen

01:17:14.812 --> 01:17:15.792
genauso funktionieren würde?

01:17:16.972 --> 01:17:18.852
Vielleicht denken ja Leute, wenn sie das in PyTest

01:17:18.852 --> 01:17:20.752
verwendet haben, ah, das funktioniert ja immer so

01:17:20.752 --> 01:17:21.972
und machen das dann irgendwann anders.

01:17:22.192 --> 01:17:24.332
Dann verhält sich das plötzlich ganz anders, als sie gedacht haben.

01:17:24.332 --> 01:17:26.873
Ja, aber man kann ja zwar Asserts

01:17:26.873 --> 01:17:28.672
ausschalten, wenn man das richtig

01:17:28.672 --> 01:17:30.933
aufruft in Interpreter, aber normalerweise

01:17:30.933 --> 01:17:32.772
macht man das ja nicht. Normalerweise fährt Assert dann einfach

01:17:32.772 --> 01:17:34.632
mit einem Assertion Error auf die Nase.

01:17:34.953 --> 01:17:37.992
Ja, ja, aber in PyTest sieht das dann wieder anders aus.

01:17:38.632 --> 01:17:41.192
Naja, aber das ist eigentlich relativ klar, oder?

01:17:41.252 --> 01:17:45.612
Dass halt, wenn ein Test fällt, dass da eine Assertion Error dann mit mehr Informationen auch zurückgegeben wird.

01:17:45.612 --> 01:17:47.132
Also, das macht der schon.

01:17:47.332 --> 01:17:50.433
Also, der im Prinzip ein fehlender Python-Test heißt, du hast eine Assertion Error.

01:17:51.632 --> 01:17:52.332
Nee, nee, nee.

01:17:52.832 --> 01:17:56.052
Ja, aber ein Python-Test macht dann halt eine Menge Dinge.

01:17:56.152 --> 01:17:58.352
Ja, gut, aber dafür ist ja das Framework ja da.

01:17:58.512 --> 01:17:59.252
Ich glaube, dass das...

01:17:59.252 --> 01:18:03.373
Ja, da wollte Ronny Pfandschmid, auch einer der Maintainer,

01:18:03.373 --> 01:18:05.552
wollte da auch mal irgendeinen Pip schreiben oder sowas,

01:18:05.772 --> 01:18:07.072
dass man sich eben bei Python

01:18:07.072 --> 01:18:09.152
gerade schön da reinhängen kann

01:18:09.152 --> 01:18:10.092
in diese Assertions.

01:18:10.232 --> 01:18:10.712
Ja, das wäre

01:18:10.712 --> 01:18:14.512
schon ganz nützlich.

01:18:14.592 --> 01:18:17.132
Für irgendwie so eine Assertion-Lib oder sowas, die man einfach importiert

01:18:17.132 --> 01:18:19.032
und dann hat man schön noch Assertions oder so, das wäre doch cool.

01:18:19.592 --> 01:18:20.992
Aber ja, wahrscheinlich ist es nicht so.

01:18:21.012 --> 01:18:23.032
Genau, aber ich glaube, da ist es leider nie was geworden.

01:18:25.893 --> 01:18:27.413
Was es gibt für Notebooks

01:18:27.413 --> 01:18:28.652
vielleicht noch ganz interessant,

01:18:29.252 --> 01:18:31.092
ein Ding namens IPyTest,

01:18:31.572 --> 01:18:33.312
was eben PyTest

01:18:33.312 --> 01:18:35.092
in diese Notebooks integriert.

01:18:35.232 --> 01:18:37.032
Man kann einfach mit Prozent-Prozent

01:18:37.032 --> 01:18:39.452
IPyTest, kann man halt PyTest ausführen

01:18:39.452 --> 01:18:41.332
und hat dann auch Zugriff

01:18:41.332 --> 01:18:42.933
gleich auf die lokalen Variablen

01:18:42.933 --> 01:18:44.272
aus dem Notebook und sowas.

01:18:45.592 --> 01:18:47.612
Und das ist, wenn man das einmal einrichtet

01:18:47.612 --> 01:18:49.272
in einem Notebook, dann kriegt man

01:18:49.272 --> 01:18:51.172
auch in diesem Notebook global

01:18:51.172 --> 01:18:52.933
quasi geschenkt

01:18:52.933 --> 01:18:55.092
die Assertion-Infos,

01:18:55.433 --> 01:18:56.592
wenn eine Assertion fehlschlägt.

01:18:56.592 --> 01:18:57.852
Ach, das geht dann auch an anderen Stellen?

01:18:59.192 --> 01:19:00.632
Genau, das

01:19:00.632 --> 01:19:02.252
hängt sich dann halt da irgendwie ein.

01:19:03.312 --> 01:19:04.612
Ach cool, das kann ich auch noch nicht

01:19:04.612 --> 01:19:06.492
Ja

01:19:06.492 --> 01:19:08.933
Noch mehr Plugins hier benutzt?

01:19:11.132 --> 01:19:11.373
Äh

01:19:11.373 --> 01:19:13.433
Finde ich nochmal Freescan, wenn ich irgendwie so

01:19:13.433 --> 01:19:15.112
Zeit sagen will, auch zu der und der Zeit

01:19:15.112 --> 01:19:17.112
oder die Zeit muss ich jetzt um zwei Stunden verschieben

01:19:17.112 --> 01:19:19.712
zwischen zwei Tests oder sowas, das ist ganz nett

01:19:19.712 --> 01:19:21.913
mit Context Manager oder so

01:19:21.913 --> 01:19:23.232
Das ist cool

01:19:23.232 --> 01:19:25.952
Ja, das habe ich schon genutzt, Responses

01:19:25.952 --> 01:19:26.852
Oh ja, ja

01:19:26.852 --> 01:19:29.473
Das ist Mocking halt für Requests

01:19:29.473 --> 01:19:31.212
Man ruft eigentlich im Prinzip

01:19:31.212 --> 01:19:33.252
wie man Request aufruft, ruft man halt erstmal

01:19:33.252 --> 01:19:35.292
Responses auf und das mockt einem das weg.

01:19:35.492 --> 01:19:37.712
Ich glaube, das gibt auch für HTTPX, wenn ich das richtig gesehen habe.

01:19:39.252 --> 01:19:41.552
Und da, ich fände es eigentlich

01:19:41.552 --> 01:19:42.712
schön, wenn es mehr so

01:19:42.712 --> 01:19:45.132
Mocking-Libraries gibt. Also sowas wie

01:19:45.132 --> 01:19:47.192
FreezeGang, VCR,

01:19:47.512 --> 01:19:49.592
Responses oder diesen HTTPX-Mock.

01:19:50.452 --> 01:19:51.712
Ich bin eigentlich der Meinung,

01:19:52.272 --> 01:19:53.433
jede Python-Library,

01:19:53.532 --> 01:19:55.512
die irgendwas macht mit externen

01:19:55.512 --> 01:19:57.612
Systemen, also sowas wie PySerial

01:19:57.612 --> 01:19:59.712
beispielsweise, sollte

01:19:59.712 --> 01:20:01.292
halt gerade auch irgendwie so

01:20:01.292 --> 01:20:03.873
Testsupport oder so Mocs gleich mitliefern

01:20:03.873 --> 01:20:05.672
und danach schöne, maintained

01:20:05.672 --> 01:20:07.873
getestete Mocs.

01:20:07.973 --> 01:20:09.672
Mocking ist immer noch sowas, das macht man

01:20:09.672 --> 01:20:11.652
irgendwie so ad hoc in jeder Testsuite

01:20:11.652 --> 01:20:13.232
wieder neu das Rad erfunden.

01:20:13.552 --> 01:20:14.672
Ja, das ist natürlich auch so.

01:20:14.672 --> 01:20:16.393
Das stimmt, da ist relativ viel Zeit immer

01:20:16.393 --> 01:20:17.792
bis man das richtig läuft.

01:20:18.413 --> 01:20:20.512
Das ist wahrscheinlich sogar der Hauptteil, den man braucht

01:20:20.512 --> 01:20:21.413
für Testschreiben.

01:20:22.572 --> 01:20:24.012
Nö, das würde ich jetzt auch nicht sagen.

01:20:24.752 --> 01:20:26.112
Aber es ist halt immer wieder

01:20:26.112 --> 01:20:26.812
das.

01:20:26.812 --> 01:20:30.473
Also was ich noch gerne mache ist Insta-Fail

01:20:30.473 --> 01:20:34.572
und dann sieht man halt direkt, wenn die Tests ein bisschen länger laufen

01:20:34.572 --> 01:20:36.373
und die Tests die Fällen schon mal, kann daran schon mal

01:20:36.373 --> 01:20:38.272
dann werkeln, weil man einfach nur

01:20:38.272 --> 01:20:39.852
sich verschrieben hat, vertippt hat oder so

01:20:39.852 --> 01:20:42.152
hat man den schon mal dann drauf und das läuft dann trotzdem

01:20:42.152 --> 01:20:43.212
noch

01:20:43.212 --> 01:20:46.532
Ich nutze noch, da bin ich jetzt nicht so

01:20:46.532 --> 01:20:48.413
stolz drauf, aber ich nutze noch PyTest

01:20:48.413 --> 01:20:49.652
Rerun Failures

01:20:49.652 --> 01:20:52.632
wo man Tests halt aus Flaky markieren kann

01:20:52.632 --> 01:20:54.292
und wenn sie fehlschlagen, werden sie halt nochmal

01:20:54.292 --> 01:20:54.933
ausgeführt

01:20:54.933 --> 01:20:57.852
weil ich bei Qt Browser

01:20:57.852 --> 01:20:59.433
halt wirklich eine Squee Applikation

01:20:59.433 --> 01:21:01.812
mit so vielen externen Komponenten

01:21:01.812 --> 01:21:03.512
dieses Problem

01:21:03.512 --> 01:21:05.913
mit Flaky Tests fast nicht in den Griff kriege

01:21:05.913 --> 01:21:09.232
und dann bis zu irgendwie

01:21:09.232 --> 01:21:11.792
eine Assertion Failure in der Libc

01:21:11.792 --> 01:21:13.552
also die Library C

01:21:13.552 --> 01:21:14.652
selbst implementiert

01:21:14.652 --> 01:21:17.652
wo ich sagen muss, dass mir jetzt so viele Labels darunter

01:21:17.652 --> 01:21:19.632
da kann ich jetzt echt nichts daran ändern

01:21:19.632 --> 01:21:21.092
also was will ich machen

01:21:21.092 --> 01:21:22.952
Ja

01:21:22.952 --> 01:21:25.852
Aber natürlich nur so jedes tausendste Mal

01:21:25.852 --> 01:21:27.973
Ja

01:21:27.973 --> 01:21:30.212
Das ist ja ganz mies, wenn irgendwie so ein Test

01:21:30.212 --> 01:21:31.933
nur jedes hundertste oder so

01:21:31.933 --> 01:21:34.373
Mal fällschlägt, das ist ja ganz eklig

01:21:34.373 --> 01:21:35.692
Irgendwie so

01:21:35.692 --> 01:21:36.772
das rauszufinden

01:21:36.772 --> 01:21:39.292
Das ist immer

01:21:39.292 --> 01:21:41.532
Ist das ein Plugin oder kann das Python testen?

01:21:41.572 --> 01:21:44.052
Das weiß ich gar nicht, aber dass man die Reihenfolge

01:21:44.052 --> 01:21:45.052
irgendwie zufällig macht

01:21:45.052 --> 01:21:47.792
Randomize oder irgendwie so

01:21:47.792 --> 01:21:49.352
Ja, da gibt es ein paar

01:21:49.352 --> 01:21:50.112
Randomly

01:21:50.112 --> 01:21:50.473
gibt es.

01:21:50.473 --> 01:21:51.112
Ja,

01:21:51.112 --> 01:21:56.992
macht eigentlich Sinn,

01:21:57.252 --> 01:21:58.512
weil eben Tests voneinander

01:21:58.512 --> 01:21:59.732
unabhängig sein sollten.

01:22:01.112 --> 01:22:02.312
Und andersrum

01:22:02.312 --> 01:22:04.452
gibt es PyTest Order, wo man sagen kann,

01:22:04.512 --> 01:22:06.433
Tests sollen halt voneinander abhängig sein

01:22:06.433 --> 01:22:08.292
in einer bestimmten Reihenfolge.

01:22:08.852 --> 01:22:10.092
Wie heißt das? Kannst du nochmal geträumt werden?

01:22:10.752 --> 01:22:12.292
PyTest Order, glaube ich.

01:22:14.792 --> 01:22:16.413
Da kommt oft die Frage

01:22:16.413 --> 01:22:18.592
dann eben von Kunden

01:22:18.592 --> 01:22:20.752
von mir, die dann irgendwie Elektronik mit PyTest

01:22:20.752 --> 01:22:21.192
testen.

01:22:22.433 --> 01:22:23.752
Weil da natürlich,

01:22:24.532 --> 01:22:26.272
wenn man jetzt eine Klimakammer hat oder so,

01:22:26.933 --> 01:22:28.572
ist das halt nun mal so, dass die Dinge

01:22:28.572 --> 01:22:29.632
voneinander abhängen.

01:22:30.652 --> 01:22:32.492
Oder dass man vielleicht alle Tests irgendwie

01:22:32.492 --> 01:22:34.572
bei 30 Grad laufen

01:22:34.572 --> 01:22:36.712
sollen, dass man die erstmal laufen lassen will,

01:22:36.792 --> 01:22:38.492
anstatt jedes Mal auf minus 10 Grad

01:22:38.492 --> 01:22:40.272
runter zu kühlen und wieder hoch auf 30.

01:22:40.612 --> 01:22:41.512
Oder wie auch immer.

01:22:42.812 --> 01:22:43.852
Macht auch keinen Sinn.

01:22:45.712 --> 01:22:46.192
Ja.

01:22:46.192 --> 01:22:48.152
Ja, PyTest

01:22:48.152 --> 01:22:50.292
BDD nutze ich noch. Ah, okay,

01:22:50.393 --> 01:22:52.232
das ist interessant. Ja, da habe ich auch schon häufiger was

01:22:52.232 --> 01:22:52.933
gehört. Ja,

01:22:54.092 --> 01:22:55.772
ich habe es auch mal versucht zu nutzen.

01:22:56.652 --> 01:22:57.732
Also, vielleicht noch mal kurz, der

01:22:57.732 --> 01:23:00.652
Behavior Driven Development

01:23:00.652 --> 01:23:02.092
Test, glaube ich auch.

01:23:02.473 --> 01:23:04.292
Man kann so Logik, so Business Logik

01:23:04.292 --> 01:23:05.952
schreiben, so für den PO oder so

01:23:05.952 --> 01:23:08.072
und der kann dann so Sätze

01:23:08.072 --> 01:23:09.652
formulieren in seiner eigenen

01:23:09.652 --> 01:23:12.032
Sprache und dann guckt Python

01:23:12.032 --> 01:23:12.952
BDD, ob es geht oder nicht.

01:23:13.952 --> 01:23:16.232
Aber so tief rein. Das ist im Prinzip einfach noch mal

01:23:16.232 --> 01:23:18.252
eine kleine Abstraktion,

01:23:18.373 --> 01:23:19.433
dass man sagen kann,

01:23:20.192 --> 01:23:22.172
given I have an author

01:23:22.172 --> 01:23:24.592
user, when I

01:23:24.592 --> 01:23:26.212
do this and that, then

01:23:26.212 --> 01:23:27.252
this and that should happen.

01:23:28.012 --> 01:23:29.433
Also mit diesem given, when, then.

01:23:29.973 --> 01:23:32.112
Das halt wirklich auf Testsprache hat

01:23:32.112 --> 01:23:33.252
und dann die Implementation

01:23:33.252 --> 01:23:35.232
der Tests

01:23:35.232 --> 01:23:38.132
eigentlich nochmal abgekapselt hat

01:23:38.132 --> 01:23:39.572
von den Test Cases.

01:23:39.732 --> 01:23:42.052
Also quasi so diese User Story reingießen.

01:23:42.052 --> 01:23:42.393
Ja.

01:23:44.512 --> 01:23:44.992
Genau.

01:23:44.992 --> 01:23:51.473
Also ich habe es wieder rausgeschmissen, ich habe es ausprobiert, aber irgendwie, wahrscheinlich lag es aber auch an dem Projekt halt, wo das halt nicht so wirklich dazu gepasst hat.

01:23:52.433 --> 01:23:53.572
Wofür verwendest du das?

01:23:54.792 --> 01:23:57.952
Ich nutze es halt ganz stark für die End-to-End-Tests für Cube Browser.

01:23:58.592 --> 01:24:03.512
Jetzt müsste ich da vielleicht nochmal kurz einhaken, was Cube Browser denn überhaupt ist, jetzt habe ich es schon ein paar Mal erwähnt.

01:24:04.352 --> 01:24:12.433
Das ist so mein Hauptprojekt seit ziemlich genau zehn Jahren, ich glaube in drei Tagen oder so sind es zehn Jahre.

01:24:12.433 --> 01:24:16.032
und zwar ein Webbrowser,

01:24:16.452 --> 01:24:18.572
der sehr stark auf Tastaturbedienung

01:24:18.572 --> 01:24:20.592
ausgelegt ist, so inspiriert

01:24:20.592 --> 01:24:22.632
von VI bzw. WIM,

01:24:24.232 --> 01:24:26.672
eben auf Chromium aufsetzt und in Python

01:24:26.672 --> 01:24:27.732
geschrieben ist.

01:24:28.112 --> 01:24:30.212
Darüber bin ich danach zu PyTest gekommen.

01:24:32.732 --> 01:24:34.232
Und das hat

01:24:34.232 --> 01:24:36.712
dann so ein Interface

01:24:36.712 --> 01:24:38.433
mit einer Commandline

01:24:38.433 --> 01:24:39.352
quasi eingebaut.

01:24:41.012 --> 01:24:42.112
Und da habe ich dann auch viele

01:24:42.112 --> 01:24:43.873
End-to-End-Tests, wo ich halt einfach irgendwo

01:24:43.873 --> 01:24:46.072
ein Kommando hinschicke zu einem laufenden

01:24:46.072 --> 01:24:48.192
Browser und dann

01:24:48.192 --> 01:24:49.933
erstmal schaue mit einem Web-Server,

01:24:50.072 --> 01:24:52.393
der direkt im PyTest-Prozess läuft,

01:24:53.393 --> 01:24:54.092
wurde dann

01:24:54.092 --> 01:24:56.072
die und die Seite aufgerufen

01:24:56.072 --> 01:24:57.492
oder ist das und das passiert.

01:24:58.893 --> 01:25:00.132
Und so diese End-to-End-Tests

01:25:00.132 --> 01:25:02.252
habe ich dann halt eben mit dem PyTest-BDD

01:25:02.252 --> 01:25:03.352
geschrieben, dass ich sage,

01:25:03.893 --> 01:25:05.812
when I run open

01:25:05.812 --> 01:25:06.732
und irgendwie

01:25:06.732 --> 01:25:10.012
then this and that page

01:25:10.012 --> 01:25:10.772
should be loaded.

01:25:12.112 --> 01:25:26.012
Ja, an der Stelle klingt das durchaus sinnvoll, weil wahrscheinlich hat man dann ganz viele davon und da will man ja wahrscheinlich dann nicht immer das ganze Boilerplate einschreiben

01:25:26.012 --> 01:25:39.132
Ja, ich weiß auch nicht, ob ich es nochmal so machen würde, weil es sind jetzt halt doch sehr viele so End-to-End-Tests geworden und da ist ein bisschen das Problem mit flaky Tests und mit langsamen Tests

01:25:39.132 --> 01:25:45.052
Aber ich glaube, für so gewisse Dinge

01:25:45.052 --> 01:25:47.072
lohnt sich das schon. Also ich fand es auch ganz

01:25:47.072 --> 01:25:49.072
angenehm, wenn da neue Leute

01:25:49.072 --> 01:25:51.092
dazukommen, die noch nie was mit PyTest gemacht

01:25:51.092 --> 01:25:53.252
haben, dass du denen sagen kannst

01:25:53.252 --> 01:25:54.992
guck, schreib dir das mal an, das

01:25:54.992 --> 01:25:56.352
ist eine schöne,

01:25:56.952 --> 01:25:58.852
eine hohe Abstraktion, nochmal höher als

01:25:58.852 --> 01:26:00.792
Python-Code und schau mal, ob du so einen Test

01:26:00.792 --> 01:26:01.473
schreiben kannst

01:26:01.473 --> 01:26:02.732
Ja

01:26:02.732 --> 01:26:06.973
An der Stelle ist es vielleicht auch noch ganz interessant, genau, das ist ja

01:26:06.973 --> 01:26:08.473
auch, selbst wenn man jetzt nicht BDD

01:26:08.473 --> 01:26:11.692
Test sozusagen so hinschreibt, sondern

01:26:11.692 --> 01:26:15.052
normale Tests, dann empfiehlt es sich da ja auch

01:26:15.052 --> 01:26:17.812
vielleicht, sich im Grunde an dieses Pattern zu halten.

01:26:18.352 --> 01:26:21.112
Also genau, Given-When-Then ist halt die eine Formulierung,

01:26:21.212 --> 01:26:23.192
wie man das halt ausdrücken kann.

01:26:23.873 --> 01:26:27.913
Es gibt noch eine andere, die nennt sich irgendwie Arrange-Act-Assert,

01:26:28.373 --> 01:26:30.052
aber es ist im Grunde beides das Gleiche.

01:26:30.512 --> 01:26:32.572
Es ist halt immer irgendwie, man baut sich zuerst irgendwie

01:26:32.572 --> 01:26:36.092
einen State zusammen, der halt

01:26:36.092 --> 01:26:36.952
irgendwie ist und dann

01:26:36.952 --> 01:26:39.792
macht man irgendwas drauf und dann guckt man hinterher,

01:26:39.873 --> 01:26:41.512
ist das rausgekommen, was man sich irgendwie

01:26:41.512 --> 01:26:44.032
was man erwartet hat und wenn nicht

01:26:44.032 --> 01:26:45.692
ist halt schlecht. Aber es macht halt

01:26:45.692 --> 01:26:50.172
Sinn, Tests immer so zu strukturieren,

01:26:50.252 --> 01:26:51.992
dass man halt auch, wenn man jetzt auf den Test guckt,

01:26:52.252 --> 01:26:53.933
sofort weiß, okay, ach, an der Stelle

01:26:53.933 --> 01:26:55.873
wird nur irgendwas zusammengebaut, an der Stelle wird jetzt

01:26:55.873 --> 01:26:58.012
der eigentliche Aufruf gemacht und hier, es hatten wir irgendwelche

01:26:58.012 --> 01:26:59.473
Dinge, wo wir dachten,

01:26:59.873 --> 01:27:00.772
das müsste jetzt da rauskommen.

01:27:02.992 --> 01:27:03.952
Das BTD, das klingt

01:27:03.952 --> 01:27:05.832
auch so ein bisschen nach, als könnte man das mit Playwright

01:27:05.832 --> 01:27:07.812
machen. Ich weiß nicht, ob das dieses Pattern auch ist.

01:27:08.092 --> 01:27:08.433
Wie mein Jochen?

01:27:10.652 --> 01:27:11.893
Die Playwright-Tests, die ich

01:27:11.893 --> 01:27:13.913
bisher gemacht habe, ne, die waren halt einfach

01:27:13.913 --> 01:27:15.332
da habe ich das alles immer von Hand hingeschrieben.

01:27:15.852 --> 01:27:16.072
Ja.

01:27:18.112 --> 01:27:19.913
Es ist halt, ja, das macht aber so ein bisschen

01:27:19.913 --> 01:27:21.652
BDD auch, oder? Also es gibt halt so einen Browser

01:27:21.652 --> 01:27:23.692
und sagt halt, okay, geh auf diese Seite

01:27:23.692 --> 01:27:25.692
und drück mal so einen Knopf und erwarte

01:27:25.692 --> 01:27:27.373
das. Ja, aber es sind schon einfach

01:27:27.373 --> 01:27:29.652
Funktionsaufrufe, es ist nicht irgendwie Text,

01:27:29.732 --> 01:27:30.913
den man hinschreibt. Ja, okay, stimmt.

01:27:30.913 --> 01:27:33.192
Ich mache es halt anders, ich soll direkt abheißen, ja.

01:27:34.272 --> 01:27:34.473
Ja.

01:27:35.832 --> 01:27:39.452
Ja, ich glaube, mir fällt kein Plugin mehr ein, was ich jetzt empfehlen wollen würde.

01:27:40.112 --> 01:27:41.252
Welche hatten wir ja schon.

01:27:42.692 --> 01:27:44.792
Da muss ich mich fragen, ob es sowas gibt.

01:27:44.893 --> 01:27:47.452
Ich weiß nicht, in der JavaScript-Welt, das sehe ich halt ab und zu mal,

01:27:47.893 --> 01:27:50.832
gibt es halt auch so Dinge, da läuft halt einfach immer irgendwie,

01:27:51.393 --> 01:27:54.352
oder da wird halt geguckt, ob sich irgendwas an den Files geändert hat.

01:27:54.352 --> 01:27:57.772
Und dann läuft halt da irgendwie der Testrunner quasi die ganze Zeit

01:27:57.772 --> 01:28:01.933
und alle Tests, die dann halt sozusagen davon beeinflusst sein könnten,

01:28:02.012 --> 01:28:03.772
von irgendeiner Änderung, werden dann halt nochmal ausgeführt.

01:28:03.772 --> 01:28:06.172
und es gibt dann so eine Art Dashboard, was halt

01:28:06.172 --> 01:28:07.772
gerade nicht funktioniert oder was funktioniert.

01:28:08.552 --> 01:28:10.092
Gibt es das für PyTest eigentlich auch?

01:28:10.172 --> 01:28:11.393
Weil ich glaube, sowas habe ich noch nicht gesehen.

01:28:12.832 --> 01:28:14.192
Ja, es gibt Testmon.

01:28:15.132 --> 01:28:15.712
Ah, okay.

01:28:16.072 --> 01:28:16.192
Cool.

01:28:16.692 --> 01:28:20.532
Ein größeres Projekt, testmon.org

01:28:20.532 --> 01:28:22.192
hatte ich mir mal

01:28:22.192 --> 01:28:24.072
angeschaut, aber jetzt auch schon länger nicht mehr.

01:28:25.452 --> 01:28:25.572
Oh.

01:28:26.232 --> 01:28:27.473
Dann paniken wir mal, gucken wir nochmal rein.

01:28:27.873 --> 01:28:30.032
Ich weiß, dass es auch ein, zwei Leute

01:28:30.032 --> 01:28:31.973
gibt, die jetzt da so ein bisschen noch schauen,

01:28:31.973 --> 01:28:34.373
wie kann ich

01:28:34.373 --> 01:28:36.292
mit Coverage halt auch dann schauen

01:28:36.292 --> 01:28:37.492
welche Tests wirklich

01:28:37.492 --> 01:28:40.272
beeinflusst sind von der Änderung und sowas

01:28:40.272 --> 01:28:42.332
aber es ist schon noch so

01:28:42.332 --> 01:28:43.512
etwas, was jetzt nicht

01:28:43.512 --> 01:28:45.473
so in fix fertig

01:28:45.473 --> 01:28:47.132
jetzt eben außer Testmon

01:28:47.132 --> 01:28:49.492
es gibt schon in fix fertig, aber jetzt auch noch was

01:28:49.492 --> 01:28:51.532
was ich weiß, dass Leute dann arbeiten

01:28:51.532 --> 01:28:55.092
ja

01:28:55.092 --> 01:28:57.992
ja, ansonsten

01:28:57.992 --> 01:28:59.632
ich weiß nicht, was haben wir denn noch so für Themen

01:28:59.632 --> 01:29:01.532
noch irgendwie

01:29:01.532 --> 01:29:03.572
größere Dinge gar nicht besprochen

01:29:03.572 --> 01:29:04.032
oder

01:29:04.032 --> 01:29:07.812
ja, vielleicht noch

01:29:07.812 --> 01:29:10.112
den Development Sprint

01:29:10.112 --> 01:29:12.393
naja, und zwar

01:29:12.393 --> 01:29:13.893
gab es im

01:29:13.893 --> 01:29:16.592
2016

01:29:16.592 --> 01:29:18.552
glaube ich mal einen Development Sprint

01:29:18.552 --> 01:29:20.373
wo wir uns alle mal getroffen

01:29:20.373 --> 01:29:22.473
hatten in Freiburg im Breisgau

01:29:22.473 --> 01:29:24.352
und halt mal zusammen

01:29:24.352 --> 01:29:26.252
rumgehackt haben an PyTest

01:29:26.252 --> 01:29:28.252
zum einen halt eben so

01:29:28.252 --> 01:29:31.232
die wirklichen Verdächtigen, die Core-Entwickler

01:29:31.232 --> 01:29:34.712
zum anderen, aber auch ganz viele Leute von irgendwelchen Plugins

01:29:34.712 --> 01:29:37.252
oder auch einfach Leute, die mal was an PyTest machen wollten

01:29:37.252 --> 01:29:40.132
und ich bin gerade daran

01:29:40.132 --> 01:29:43.332
fürs 24 sowas wieder zu organisieren

01:29:43.332 --> 01:29:46.272
müsst ihr wahrscheinlich mal noch schauen, dass ich das

01:29:46.272 --> 01:29:49.913
auf die PyTest-Webseite auch mache, weil bisher war die Resonanz

01:29:49.913 --> 01:29:53.032
nicht so viel

01:29:53.032 --> 01:29:54.632
ich

01:29:54.632 --> 01:30:07.952
Ich habe da halt mal von einem Kunden von mir das Angebot bekommen, dass die uns da hosten, weiß ich, in Vorarlberg, was erstmal so im Nirgendwo ist.

01:30:08.692 --> 01:30:09.212
Vorarlberg?

01:30:09.332 --> 01:30:10.792
In einem Städtchen da mit Tiefenalpen irgendwo.

01:30:11.712 --> 01:30:17.632
Ja, das ist tatsächlich ziemlich nah. Als Österreich, aber gerade an der Schweizer Grenze.

01:30:18.672 --> 01:30:21.612
In einem Dorf mit irgendwie 3000 Leuten oder so.

01:30:21.612 --> 01:30:24.272
sind die zu Hause

01:30:24.272 --> 01:30:26.612
Omikron heißen die

01:30:26.612 --> 01:30:29.272
und die hatten mir angeboten

01:30:29.272 --> 01:30:31.232
das halt da zu hosten

01:30:31.232 --> 01:30:33.112
und meinten noch

01:30:33.112 --> 01:30:34.952
ja, wir können da gratis essen

01:30:34.952 --> 01:30:36.873
und so und haben Sitzungsräume und sowas

01:30:36.873 --> 01:30:40.952
und da hatte ich jetzt mal

01:30:40.952 --> 01:30:42.692
so eine Umfrage gemacht

01:30:42.692 --> 01:30:44.812
wer dann so kommen will und es haben sich halt irgendwie

01:30:44.812 --> 01:30:46.212
fünf Leute oder so gemeldet

01:30:46.212 --> 01:30:49.092
ich würde da eigentlich ganz gerne

01:30:49.092 --> 01:30:50.352
ein paar mehr Leute noch haben

01:30:50.352 --> 01:30:52.752
Also eben in 2016

01:30:52.752 --> 01:30:54.712
waren es 27 Leute

01:30:54.712 --> 01:30:58.433
Diesmal könnten wir schon so

01:30:58.433 --> 01:31:00.433
30, 35 oder so könnten wir

01:31:00.433 --> 01:31:00.973
hosten

01:31:00.973 --> 01:31:04.452
Wahrscheinlich dann auch mit Preise

01:31:04.452 --> 01:31:06.513
teilweise bezahlt und sowas Unterkunft

01:31:06.513 --> 01:31:08.592
teilweise bezahlt, müsste man sich alles im Detail

01:31:08.592 --> 01:31:10.292
mal anschauen, wenn

01:31:10.292 --> 01:31:12.212
wirklich die Resonanz auch da ist

01:31:12.212 --> 01:31:14.612
Ja cool, also da kann man sich auf jeden Fall

01:31:14.612 --> 01:31:16.152
mal melden, wenn man da Interesse hat

01:31:16.152 --> 01:31:17.952
Wann wäre das denn ungefähr?

01:31:17.952 --> 01:31:19.492
Im Sommer?

01:31:20.352 --> 01:31:21.933
Genau im Juni.

01:31:22.092 --> 01:31:22.852
Wir haben zwei Wochen.

01:31:24.752 --> 01:31:26.752
Mitte, Ende Juni

01:31:26.752 --> 01:31:28.672
müssen wir noch schauen, welche Woche

01:31:28.672 --> 01:31:29.212
das wird.

01:31:31.433 --> 01:31:32.412
Dann wäre eben

01:31:32.412 --> 01:31:34.112
die Hoffnung, dass

01:31:34.112 --> 01:31:36.433
wir da Leute zusammenkriegen,

01:31:36.513 --> 01:31:38.433
die irgendwas machen wollen. Ohne eine fixe

01:31:38.433 --> 01:31:39.672
Idee zu haben, was genau,

01:31:40.013 --> 01:31:41.172
es kommt dann mal alles noch.

01:31:42.232 --> 01:31:43.873
Aber halt einfach so ein Development Sprint

01:31:43.873 --> 01:31:46.292
wieder mal zu haben und sich mal wieder in Person zu sehen.

01:31:47.513 --> 01:31:48.152
Gute Sache.

01:31:48.152 --> 01:31:49.112
Das ist mal super sowas.

01:31:50.352 --> 01:31:53.132
Ja, was gibt's noch?

01:31:54.072 --> 01:31:55.513
Ich würde sagen, mit PyTest

01:31:55.513 --> 01:31:56.973
sind wir, glaube ich, mit den Themen, die

01:31:56.973 --> 01:31:58.973
ich zumindest auf der Liste hatte, soweit

01:31:58.973 --> 01:32:01.632
Dann können wir vielleicht zu den Pics

01:32:01.632 --> 01:32:03.532
der Woche des

01:32:03.532 --> 01:32:04.433
Monats der Folge übergehen

01:32:04.433 --> 01:32:05.712
Ja, können wir gerne machen

01:32:05.712 --> 01:32:09.172
Was kann man richtig mal? Kapitelmarker?

01:32:09.433 --> 01:32:10.873
Pics? Upsi

01:32:10.873 --> 01:32:12.852
Also ich

01:32:12.852 --> 01:32:14.492
picke fstring.help

01:32:14.492 --> 01:32:17.192
Aha, für mich geehrt

01:32:17.192 --> 01:32:19.412
Ich glaube, ich hatte

01:32:19.412 --> 01:32:49.393
und PyTest.

01:32:49.412 --> 01:33:19.393
und PyTest.

01:33:19.412 --> 01:33:21.272
aber die 22 ist auf jeden Fall, ich glaube, die habe ich,

01:33:22.252 --> 01:33:22.992
das Ding ist echt...

01:33:22.992 --> 01:33:25.672
Eigentlich müssen wir dazu eh nochmal eine Folge machen, ich würde sagen, der Einstiegskurs

01:33:25.672 --> 01:33:27.732
ist vielleicht sogar CS50

01:33:27.732 --> 01:33:29.552
AI with Python für die Leute, die so

01:33:29.552 --> 01:33:31.712
ein bisschen mehr anfangen, die Grundlagen

01:33:31.712 --> 01:33:32.873
irgendwie und dann

01:33:32.873 --> 01:33:35.252
parallel mit der

01:33:35.252 --> 01:33:37.492
Video Tutorial Serie von Enrico Capazzi

01:33:37.492 --> 01:33:38.812
ein Fast AI.

01:33:39.912 --> 01:33:41.352
Ja. Würde ich sagen, dass dann ist

01:33:41.352 --> 01:33:43.272
mein Datasign schon mit der Nase

01:33:43.272 --> 01:33:44.112
ganz schön tief drin.

01:33:45.272 --> 01:33:47.412
Wenn man so ein bisschen noch Statistik macht, vielleicht dann...

01:33:47.412 --> 01:34:07.192
Oh, und dann picke ich vielleicht die andere Geschichte, die ich mir auch aufgeschrieben hatte, gleich mit. Es gibt eine super schöne Visualisierung von wie funktionieren diese LLMs eigentlich, wo man halt sieht, wie ein Token irgendwie oben so grafisch irgendwo reinfällt und dann halt irgendwie in Embeddings umgewandelt wird und dann durch diese ganze Maschinerie durchläuft. Dann kann man auch auswählen, welches Modell hätte man gerne.

01:34:07.192 --> 01:34:09.873
und das, wenn man das benutzt,

01:34:09.952 --> 01:34:11.632
das ist aber eine beeindruckende Visualisierung

01:34:11.632 --> 01:34:13.412
und naja, das ist ja bestimmt alles irgendwie nur so,

01:34:13.852 --> 01:34:15.612
hat sich jemand halt, ein Grafiker halt hingemalt

01:34:15.612 --> 01:34:17.632
oder sowas, nein, es ist tatsächlich, es sind die echten

01:34:17.632 --> 01:34:19.412
mehr oder weniger, also gut,

01:34:19.513 --> 01:34:21.632
vielleicht nicht in jedem letzten Detail, aber es sind schon fast die,

01:34:22.072 --> 01:34:23.412
schon quasi die echten Modelle

01:34:23.412 --> 01:34:25.612
und da hat sich jemand echt Mühe gegeben und

01:34:25.612 --> 01:34:27.492
in WebAssembly die ganzen

01:34:27.492 --> 01:34:29.652
Operationen

01:34:29.652 --> 01:34:31.013
alle nachimplementiert und

01:34:31.013 --> 01:34:33.412
das ist schon großartig, es gibt auch

01:34:33.412 --> 01:34:34.492
den Source dazu.

01:34:34.492 --> 01:34:37.192
Ja, es ist halt hauptsächlich

01:34:37.192 --> 01:34:38.812
TypeScript und WebAssembly

01:34:38.812 --> 01:34:40.873
Du meinst aber nicht MoneyML

01:34:40.873 --> 01:34:42.452
MoneyML

01:34:42.452 --> 01:34:44.592
Ne, wüsste ich jetzt nicht

01:34:44.592 --> 01:34:46.092
Also es ist halt einfach so grafisch

01:34:46.092 --> 01:34:48.812
Man sieht halt quasi wie so ein

01:34:48.812 --> 01:34:50.513
Ergebnis von so einem Modell berechnet wird

01:34:50.513 --> 01:34:51.552
halt grafisch

01:34:51.552 --> 01:34:52.513
Und wie heißt das?

01:34:54.312 --> 01:34:55.792
Also ich kenne MoneyML

01:34:55.792 --> 01:34:58.052
Weil da muss ich mal grad nachgucken

01:34:58.052 --> 01:35:00.513
ob das

01:35:00.513 --> 01:35:01.433
genau so

01:35:01.433 --> 01:35:03.112
heißt

01:35:03.112 --> 01:35:07.052
Das heißt einfach nur

01:35:07.052 --> 01:35:08.532
LLM Visualization

01:35:08.532 --> 01:35:11.212
und bbcroft.net

01:35:11.212 --> 01:35:13.172
Also was man mit MoneyMill

01:35:13.172 --> 01:35:14.973
kann man quasi seine eigenen Sachen aufbauen.

01:35:15.393 --> 01:35:17.072
Da kann man sich auswählen, welche Layer man

01:35:17.072 --> 01:35:19.152
in sein Neural-Network reinsteckt und dann

01:35:19.152 --> 01:35:21.132
sowas bauen. Oh, das

01:35:21.132 --> 01:35:21.912
sieht aber auch schick aus.

01:35:22.252 --> 01:35:23.952
Ja, kann man jetzt nicht sehen, wenn man es nur hört.

01:35:24.312 --> 01:35:27.052
Ja, Jochen hat es gerade aufgemacht auf dem Screen. Das sieht sehr

01:35:27.052 --> 01:35:28.652
nice aus. Das bitte auch einmal linken.

01:35:29.792 --> 01:35:31.232
Genau, das hätte ich dann halt auch nochmal verlinken.

01:35:31.652 --> 01:35:33.052
Ja, dann machst du MoneyMill direkt

01:35:33.052 --> 01:35:34.433
noch dazu, dann haben wir beide.

01:35:34.772 --> 01:35:36.072
Okay, mach ich das auch.

01:35:37.272 --> 01:35:37.473
Ja.

01:35:39.433 --> 01:35:40.473
Florian, hast du auch einen Pick?

01:35:41.792 --> 01:35:42.912
Ja, ich hatte

01:35:42.912 --> 01:35:45.032
erstmal gar nichts und jetzt sind mir da gleich zwei Dinge

01:35:45.032 --> 01:35:45.552
eingefallen.

01:35:47.292 --> 01:35:48.912
Zum einen, als du

01:35:48.912 --> 01:35:51.172
Data Visualization erwähnt hattest,

01:35:51.172 --> 01:35:53.052
eine Webseite, die ich

01:35:53.052 --> 01:35:54.652
letztens von

01:35:54.652 --> 01:35:56.473
einem Kollegen gekriegt habe,

01:35:56.672 --> 01:35:58.212
datatowiz.com,

01:35:59.473 --> 01:36:01.132
was einem so durchleitet, wenn ich

01:36:31.132 --> 01:36:32.832
mehr Regeln dazu, das irgendwie

01:36:32.832 --> 01:36:35.412
um sein dann

01:36:35.412 --> 01:36:36.352
unmöglich zu machen.

01:36:38.132 --> 01:36:39.632
Und basierend darauf

01:36:39.632 --> 01:36:41.812
Das Passwort

01:36:41.812 --> 01:36:42.373
gehen wir nicht auch.

01:36:43.652 --> 01:36:45.112
Und basierend darauf hat jemand halt

01:36:45.112 --> 01:36:47.272
The Evol Game gemacht, wo man eine Python

01:36:47.272 --> 01:36:49.013
Expression eingeben muss, die dann immer

01:36:49.013 --> 01:36:50.732
mehr und mehr Regeln folgen.

01:36:51.172 --> 01:36:52.192
Okay, interessant.

01:36:53.032 --> 01:36:53.632
Das klingt gut.

01:36:56.513 --> 01:36:58.032
The digits in your password

01:36:58.032 --> 01:36:59.452
must add up to 25.

01:36:59.452 --> 01:37:01.612
Großartig

01:37:01.612 --> 01:37:02.652
Sehr gute Idee

01:37:02.652 --> 01:37:05.912
Ganz so ähnlich sieht es nach meinem EvoGame aus

01:37:05.912 --> 01:37:09.812
Ja, ne, vielen Dank

01:37:09.812 --> 01:37:10.612
Das klingt doch super

01:37:10.612 --> 01:37:11.452
Ja

01:37:11.452 --> 01:37:14.152
Ja

01:37:14.152 --> 01:37:17.272
Ja, ich glaube, dann sind wir

01:37:17.272 --> 01:37:18.212
Ich glaube, dann sind wir durch

01:37:18.212 --> 01:37:20.632
Wie, da warst du da, Florian?

01:37:20.712 --> 01:37:21.832
Ich fand es sehr schön

01:37:21.832 --> 01:37:24.672
Ja, danke euch

01:37:24.672 --> 01:37:26.893
Viele Dinge, die ich noch nicht wusste

01:37:26.893 --> 01:37:29.393
Ja, Python ist ein ganz essentieller

01:37:29.393 --> 01:37:30.992
Teil, glaube ich, von dem, was wir so machen.

01:37:32.212 --> 01:37:32.893
Auf jeden Fall.

01:37:33.632 --> 01:37:35.412
Ja, dann danke, Florian. Bleibt uns

01:37:35.412 --> 01:37:36.812
alle gewogen. Danke, Jochen.

01:37:37.612 --> 01:37:39.492
Schreibt einen, wenn ihr noch was wissen

01:37:39.492 --> 01:37:41.552
wollt, Fragen habt, Anregungen, Kommentare.

01:37:41.712 --> 01:37:43.572
Vielen Dank auch für unsere lieben Hörerinnen und Hörer,

01:37:43.572 --> 01:37:45.452
die uns Fanpost schicken oder

01:37:45.452 --> 01:37:47.152
Fragen stellen und so. Das ist immer sehr nett.

01:37:47.672 --> 01:37:49.252
Hallo at PythonPodcast.de

01:37:49.252 --> 01:37:50.893
könnt ihr uns erreichen.

01:37:52.013 --> 01:37:53.292
Dann bis bald und ein

01:37:53.292 --> 01:37:55.252
gutes Jahresende, kann man ja fast schon sagen.

01:37:55.352 --> 01:37:57.232
Wir sind ja bald schon im sechsten Podcast. Ja, Jochen?

01:37:57.912 --> 01:37:59.373
Ach du Himini, echt? Ist das schon so lang

01:37:59.373 --> 01:37:59.752
Ja

01:37:59.752 --> 01:38:04.013
Jetzt fühle ich mich ja noch älter als ich normalerweise schon fühle

01:38:04.013 --> 01:38:07.192
Heißt also, die Folge muss jetzt

01:38:07.192 --> 01:38:08.373
noch dieses Jahr rauskommen

01:38:08.373 --> 01:38:09.312
Das wird aber auch noch

01:38:09.312 --> 01:38:11.852
Weiter abkommen

01:38:11.852 --> 01:38:15.893
Ja, schauen wir mal

01:38:15.893 --> 01:38:16.312
Also

01:38:16.312 --> 01:38:18.373
Vielen Dank für eure Aufmerksamkeit

01:38:18.373 --> 01:38:19.332
Ja, ebenso

01:38:19.332 --> 01:38:20.712
Tschüss