[PYTHON] Erste Schritte mit TDD mit Cyber-dojo bei MobPro

Einführung

Dies ist der Artikel am 10. Tag von Inatatsu Adcare.

Dieses Mal wird vom letzten Mal an die Teilnahme von Do Mob Programming in Kansai ~ Hin ?? weitergeleitet.

Dieses Mal werde ich schreiben, wie TDD ist, basierend auf den Fakten (leicht modifiziert) des Flusses, wenn TDD zum ersten Mal tatsächlich durchgeführt wird.

Zum ersten Mal

Starten Sie pytest, FizzBuzz auf die gleiche Weise wie Vorheriger Artikel.  Wenn Sie es testen und wütend werden können, implementieren Sie es, damit Sie nicht wütend werden.

Der Test bestand und es wurde grün. Bis zu diesem Punkt ist es das gleiche wie beim letzten Mal.

Sie haben jetzt bestätigt, dass der Test bestanden wurde, wenn er Ihren Anforderungen entspricht.

Versuchen Sie es mit fizzbuzz

Nachdem der Wanderer veraltet ist, schreiben wir hiker.py und test_hiker.py in fizzbuzz um, um diese Anfrage zu erfüllen.

Es gibt kein Modul wie Wanderer! Ich war sauer. Lassen Sie es uns entsprechend verschiedenen Fizzbuzz umschreiben.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

test_fizzbuzz.py

import fizzbuzz


def test_life_the_universe_and_everything():
    '''a simple example to start you off'''
    douglas = fizzbuzz.FizzBuzz()
    assert douglas.answer() == 42

Führen Sie den Test als aus. Der Test war erfolgreich! !! Dies ist eine entzückende Entdeckung des Jahrhunderts (übertrieben). Derzeit freut sich jeder, glücklich zu sein.

Der Status hat sich von Rot zu Grün geändert. Als Nächstes folgt Refactoring.

Machen wir es uns vorerst einfach, die Kommentare von Anfang an zu löschen. Außerdem habe ich den Importbereich des Testcodes aufgeräumt.

test_fizzbuzz.py

from fizzbuzz import FizzBuzz


def test_life_the_universe_and_everything():
    douglas = FizzBuzz()
    assert douglas.answer() == 42

Das Programm wurde ein wenig überarbeitet. Ich habe das Programm umgeschrieben, also werde ich es testen. Es wäre ein Problem, wenn die bestandenen Tests nicht bestanden würden. Sie haben den Testcode erfolgreich bestanden.

FizzBuzz hat begonnen! !!

Nachdem ich den Fluss von TDD verstanden habe, werde ich mit FizzBuzz fortfahren. Lassen Sie uns zunächst die Anforderungen von FizzBuzz in eine angemessene Granularität aufteilen.

Was ist das kleinste Szenario von FizzBuzz?

Um über das kleinste Szenario von FizzBuzz nachzudenken, identifizieren Sie zunächst die erforderlichen Elemente für FizzBuzz.

• Wenn das Argument 1 ist, ist der Rückgabewert 1.
• Wenn das Argument 2 ist, ist der Rückgabewert 2.
• Wenn das Argument 3 ist, ist der Rückgabewert Fizz --Wenn das Argument 5 ist, ist der Rückgabewert Buzz
• Wenn das Argument 6 ist, ist der Rückgabewert Fizz
• Wenn das Argument 10 ist, ist der Rückgabewert Buzz
• Wenn das Argument 15 ist, ist der Rückgabewert FizzBuzz
• Wenn das Argument 30 ist, ist der Rückgabewert FizzBuzz

Ist es so etwas? Für das kleinste Szenario ist diesmal der oberste "Rückgabewert 1, wenn das Argument 1 ist".

Ursprünglich sollten wir die Anforderungen auf diese Weise trennen und identifizieren, aber da es das erste Mal war, haben wir sie weggelassen.

Test und Implementierung mit einem Rückgabewert von 1, wenn das Argument 1 ist

TDD schreibt zuerst den Testcode. Testen wir für die Methode, die fizzbuzz ausführt, den Rückgabewert für das Argument mit fizzbuzz.

test_fizzbuzz.py

from fizzbuzz import FizzBuzz


def test_life_the_universe_and_everything():
    douglas = FizzBuzz()
    assert douglas.answer() == 42

def test_Wenn das Argument 1 ist, ist der Rückgabewert 1.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(1) == "1"

Wenn ich den Test durchführe, gibt es keine Fizzbuzz-Methode! Ich bin wütend, aber ich freue mich darauf, wütend zu werden und den Test zu bestehen.

Es passierte. Wie erwartet.

Lassen Sie uns nun fizzbuzz implementieren.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(i):
        return "1"

Dies wird den Test bestehen! Okay, es ist ein Test! !!

Nun, ich habe eine Fehlermeldung erhalten, dass die Anzahl der Argumente seltsam ist.

Lass uns herumgehen.

Anscheinend musst du dich selbst übergeben. Es scheint gewöhnlich Selbst genannt zu werden.

Jetzt ändern wir das Programm.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, i):
        return '1'

Wenn Sie genau hinschauen, können Sie sehen, dass das Antwortargument auch Selbst hat. Anschließend wurde das Selbst als Argument angegeben.

Oh, das hat den Test bestanden.

Sie haben erfolgreich "Rückgabewert ist 1, wenn das Argument 1 ist" gelöscht. Doppelbeschichtung und Einzelbeschichtung werden beim Refactoring gemischt. Lassen Sie uns also zu einer Einzelbeschichtung vereinen.

Nachdem das Mindestszenario erfolgreich abgeschlossen wurde, wird es geliefert! !!

Nein, nun, ich habe nur bei 1 getestet, also denke ich, dass es in Ordnung ist, aber lass uns einen Test bei 2 machen, also lass uns bei 2 testen.

Wenn das Argument 2 ist, ist der Rückgabewert 2.

Schreiben Sie wie zuvor den Test für Fall 2.

test_fizzbuzz.py

from fizzbuzz import FizzBuzz


def test_life_the_universe_and_everything():
    douglas = FizzBuzz()
    assert douglas.answer() == 42

def test_Wenn das Argument 1 ist, ist der Rückgabewert 1.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(1) == '1'
    
    def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'

Etwas wie das. Es wurde ein Test hinzugefügt, um 2 zurückzugeben, wenn 2. Okay, lass uns testen.

Es ist ein Fehler. Ich bin froh, dass ich es nicht so geliefert habe, wie es ist ...

Der Fehlerinhalt ist, dass ich 2 möchte, aber nicht einziehen möchte.

Ich war beunruhigt. Was nun? Ein weiser Programmierer sagte hier. "Lassen Sie uns das Argument so zurückgeben, wie es ist" Der Schreibkraft schreibt den Code neu, wie ihm gesagt wird.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, i):
        return i

Hoppla? Ich habe zwei Fehler. Da ich die Übereinstimmung zwischen der Zeichenfolge und der Zahl überprüft habe, werde ich das Argument in eine Zeichenfolge konvertieren und es vorerst zurückgeben.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, i):
        return str(i)

Lass es uns testen.

Der Test war erfolgreich. Lass uns sehr glücklich sein.

• Wenn das Argument 1 ist, ist der Rückgabewert 1.
• Wenn das Argument 2 ist, ist der Rückgabewert 2.

Ich konnte die beiden Elemente löschen.

Es ist Refactoring.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        return str(arg)

Das Argument i ist schwer zu verstehen, also nennen wir es arg.

Wenn das Argument 3 ist, ist der Rückgabewert Fizz

Es ist Zeit, einen Test zu schreiben, um nach Fehlern zu suchen.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg == 3):
            return 'Fizz'
        return str(arg)

test_fizzbuzz.py

from fizzbuzz import FizzBuzz


def test_life_the_universe_and_everything():
    douglas = FizzBuzz()
    assert douglas.answer() == 42

def test_Wenn das Argument 1 ist, ist der Rückgabewert 1.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(1) == '1'
    
def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'
    
def test_Wenn das Argument 3 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(3) == 'Fizz'

Dies hat in Fall 3 gut funktioniert.

Lassen Sie uns nun die Spezifikationen überprüfen.

readme.txt

Write a program that prints the numbers from 1 to 100.
But for multiples of three print "Fizz" instead of the
number and for the multiples of five print "Buzz". For
numbers which are multiples of both three and five
print "FizzBuzz".

Sample output:

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
... etc up to 100

Selbst im Fall von 6 wird Fizz in den Spezifikationen angegeben, wenn es angezeigt wird.

Lassen Sie uns einen Test erstellen und testen, wenn das Argument 6 und der Rückgabewert Fizz ist.

6 ist der Rückgabewert. TU das nicht.

Beachten Sie die Spezifikationen.

Es stellt sich heraus, dass ich Fizz anzeigen möchte, wenn es durch 3 teilbar ist.

Und Mob sagt: "Bitte schreiben Sie die if-Anweisung so um, dass sie als Fizz angezeigt wird, wenn der Rest von 3 0 ist." Die Schreibkraft implementiert wie eine Maschine.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 3 == 0):
            return 'Fizz'
        return str(arg)

Es wurde unter der Bedingung des Restes umgeschrieben.

Ich konnte Fizz sicher anzeigen, wenn es ein Vielfaches von 3 war.

Werfen wir einen Blick auf den aktuellen Testcode.

test_fizzbuzz.py

from fizzbuzz import FizzBuzz


def test_life_the_universe_and_everything():
    douglas = FizzBuzz()
    assert douglas.answer() == 42

def test_Wenn das Argument 1 ist, ist der Rückgabewert 1.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(1) == '1'
    
def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'
    
def test_Wenn das Argument 3 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(3) == 'Fizz'
    
def test_Wenn das Argument 6 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(6) == 'Fizz'

Benötigen Sie so viele Tests? In diesem Refactoring werden unnötige Tests entfernt.

test_fizzbuzz.py

from fizzbuzz import FizzBuzz

    
def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'

def test_Wenn das Argument 6 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(6) == 'Fizz'

Solange diese beiden verwendet werden, ist es möglich, mit Vielfachen anstelle von festen Werten zu verarbeiten.

Das Entfernen unnötiger Testfälle ist auch ein gutes Refactoring.

Wenn das Argument 5 ist, ist der Rückgabewert Buzz

Da ich die Spezifikationen zuvor überprüft habe, ist es offensichtlich, dass dies auch ein Vielfaches von 5 ist. Daher werde ich den Testcode für die Fälle 5 und 10 schreiben und ihn implementieren.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 3 == 0):
            return 'Fizz'
        if (arg % 5 == 0):
            return 'Buzz'
        return str(arg)

test_fizzbuzz.py

from fizzbuzz import FizzBuzz

    
def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'

def test_Wenn das Argument 6 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(6) == 'Fizz'
   
def test_Wenn das Argument 5 ist, ist der Rückgabewert Buzz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(5) == 'Buzz'
    
def test_Wenn das Argument 10 ist, ist der Rückgabewert Buzz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(10) == 'buzz'

Ups Fehler, das ist der falsche Testfall. Lass es uns reparieren.

Löschen wir den unnötigen Testcode h. Löschen Sie 5 Fälle.

Wenn das Argument 15 ist, lautet der Rückgabewert FizzBuzz

Da ich die Spezifikationen zuvor überprüft habe, ist es offensichtlich, dass dies auch ein Vielfaches von 15 ist. Daher werde ich den Testcode für die Fälle 15 und 30 schreiben und ihn implementieren.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 3 == 0):
            return 'Fizz'
        if (arg % 5 == 0):
            return 'Buzz'
        if (arg % 15 == 0):
            return 'FizzBuzz'
        return str(arg)

test_fizzbuzz.py

from fizzbuzz import FizzBuzz

    
def test_Wenn das Argument 2 ist, ist der Rückgabewert 2.():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(2) == '2'

def test_Wenn das Argument 6 ist, ist der Rückgabewert Fizz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(6) == 'Fizz'
    
def test_Wenn das Argument 10 ist, ist der Rückgabewert Buzz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(10) == 'Buzz'
    
def test_Wenn das Argument 15 ist, lautet der Rückgabewert FizzBuzz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(15) == 'FizzBuzz'
    
def test_Wenn das Argument 30 ist, lautet der Rückgabewert FizzBuzz():
    douglas = FizzBuzz()
    assert douglas.fizzbuzz(30) == 'FizzBuzz'
    

Es scheint, dass es als Fizz angezeigt wird. Es scheint, dass Vielfache von 3 zuerst reagiert haben. Dies ist auch der Fall, da die Bestätigung von Vielfachen von 3 in der Reihenfolge der Bestätigung von Vielfachen von 5 und der Bestätigung von Vielfachen von 15 bestätigt wird.

Lassen Sie uns die Reihenfolge ändern.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        if (arg % 3 == 0):
            return 'Fizz'
        if (arg % 5 == 0):
            return 'Buzz'

        return str(arg)

Es hat funktioniert und Sie können es jetzt liefern. Die Szene ist ein großer Jubel.

Nun zum endgültigen Refactoring.

Es ist unangenehm zu haben, wenn Aussagen in einer Reihe stehen, also benutze usw. fest.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        else if (arg % 3 == 0):
            return 'Fizz'
        else if (arg % 5 == 0):
            return 'Buzz'

        return str(arg)

Anscheinend scheint Python, wenn es nicht funktioniert, abhängig von elif zu verzweigen. Übrigens, lassen Sie uns den Fall, der Zahlen ausgibt, in else setzen

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else
            return str(arg)

Ich werde es testen. Mit diesem, ...

Ich habe nicht. .. .. ..

Du hast den Doppelpunkt komplett vergessen.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)

Diesmal ist es geschafft.

Es ist endlich geliefert! Applaus Heute wird eine Trinkparty sein. Ich habe keine Trinkparty.

Am Ende

Der Gesamtfluss, als ich TDD zum ersten Mal mit MobPro ausprobierte, und die Details des Fehlers wurden so geliefert, wie sie waren (nicht so sehr).

So was

1. Schreiben Sie einen Test
2. Implementieren
3. Refactoring

TDD wird durch Drehen des Zyklus von durchgeführt, aber es war sehr interessant, es mit einem etwas anderen Gefühl tun zu können, indem man es mit MobPro macht. Das Ergebnis des Tests war leicht zu verstehen, ich habe versucht, es vorerst auszuführen, und wenn ich wütend wurde, habe ich immer gegoogelt und dann den Code geschrieben, also war es sehr erfrischend.

Mob Pro, lass es uns tun

Bonus

** Letztes und letztes Refactoring **

Jemand sagte. "Die Sprache, die ich benutze, hat einen ternären Operator, aber was ist mit Python?"

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz_bu(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)
            
    def fizzbuzz (self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)

Vorerst werde ich es in die ternäre Operatorversion umschreiben, während ich das fertige Programm verlasse.

Zunächst gab es einen Befehl, nur den Fall von Vielfachen von 5 durch den ternären Operator zu ersetzen.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz_bu(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)
            
    def fizzbuzz (self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        arg = 'Buzz' if arg % 5 == 0 else arg

        return str(arg)

Das Refactoring ist erfolgreich, da Sie bestätigen können, dass der Test bestanden wurde. Lassen Sie uns einen anderen Fall ersetzen,

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz_bu(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)
            
    def fizzbuzz (self, arg):
        arg = 'FizzBuzz' if arg % 15 == 0 else arg
        arg = 'Fizz' if arg % 3 == 0 else arg
        arg = 'Buzz' if arg % 5 == 0 else arg

        return str(arg)

Ich habe viele Fehler bekommen. Das ist auch natürlich. Ich versuche, den Rest der Zeichenfolge zu bekommen.

Was ist also mit einem einzelnen ternären Operator? Also habe ich versucht, den Inhalt von else und die Substitution zu löschen.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz_bu(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)
            
    def fizzbuzz (self, arg):
        arg = 'FizzBuzz' if arg % 15 == 0 else 
        'Fizz' if arg % 3 == 0 else 
        'Buzz' if arg % 5 == 0 else 

        return str(arg)

Ich werde testen, während ich sage "Das wird funktionieren !!!".

TU das nicht.

Ich frage mich, ob Zeilenumbrüche nicht gut sind, und als ich durchging, wie man ein Programm mit langen Sätzen in mehrere Zeilen aufteilt, gab es eine Stimme, die sagte, ich könnte mit einem Backslash arbeiten, also werde ich es hinzufügen.

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz_bu(self, arg):
        if (arg % 15 == 0):
            return 'FizzBuzz'
        elif (arg % 3 == 0):
            return 'Fizz'
        elif (arg % 5 == 0):
            return 'Buzz'
        else:
            return str(arg)
            
    def fizzbuzz (self, arg):
        arg = 'FizzBuzz' if arg % 15 == 0 else \
        'Fizz' if arg % 3 == 0 else \
        'Buzz' if arg % 5 == 0 else \
        arg
        return str(arg)

Hurra! Es ist ein Erfolg! !! Der Jubel wird steigen, sobald er abgeschlossen ist. Nachdem wir eine ternäre Operatorversion haben, löschen Sie das Backup und es ist Zeit zu liefern! !! !! !! !! !! !!

fizzbuzz.py

class FizzBuzz:

    def answer(self):
        return 6 * 7

    def fizzbuzz (self, arg):
        arg = 'FizzBuzz' if arg % 15 == 0 else 
        'Fizz' if arg % 3 == 0 else 
        'Buzz' if arg % 5 == 0 else 

        return str(arg)