Erstellen eines String-Rechners mit testgetriebener Entwicklung (TDD): Eine Schritt-für-Schritt-Anleitung

Wir werden einen String-Rechner in Python mithilfe eines testgetriebenen Entwicklungsansatzes (TDD) implementieren. Das bedeutet, dass wir Tests für jede Funktion schreiben, bevor wir die entsprechende Funktionalität implementieren.

Sie können den Link https://osherove.com/tdd-kata-1 als Kontrollpunkte für die Implementierung von TDD verwenden. Der Link enthält eine Schritt-für-Schritt-Anleitung, der Sie folgen können.

Erste Schritte

Erstellen Sie in Ihrem Projektordner zwei Dateien: string_calculator.py und tests/test_string_calculator.py. Wir implementieren die Features Schritt für Schritt. Zuerst müssen wir eine StringCalculator-Klasse mit einer Add-Methode erstellen.

Schritt 1: Leere Zeichenfolge sollte „0“ zurückgeben

Schreiben wir den ersten Test für unsere Anwendung mithilfe der Unittest-Bibliothek. Öffnen Sie die Datei „tests/test_string_calculator.py“ und beginnen Sie mit dem folgenden Code:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Jetzt implementieren wir die StringCalculator-Klasse in der Datei string_calculator.py:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Um die Tests durchzuführen, befolgen Sie diese Schritte:

1. Stellen Sie sicher, dass Sie sich im Projektverzeichnis befinden, in dem sich Ihre Dateien „string_calculator.py“ und „tests/test_string_calculator.py“ befinden.

2. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung.

3. Führen Sie den folgenden Befehl aus, um die Tests auszuführen:
   

python -m unittest discover tests

Dieser Befehl erkennt automatisch alle Tests im Testordner und führt sie aus.

Erwartete Ausgabe:

Wenn der Test erfolgreich ist, sollten Sie etwa Folgendes sehen:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Wenn alles richtig eingerichtet ist und der Testfall erfolgreich ist, bedeutet das, dass Ihre Implementierung für die Behandlung einer leeren Zeichenfolge wie erwartet funktioniert.

Schritt 2: Das Addieren einer oder zweier Zahlen sollte ihre Summe ergeben

Wir müssen die Methode aktualisieren, um den Fall zu behandeln, in dem die Eingabezeichenfolge nur eine oder zwei Zahlen enthält, und sie sollte deren Summe zurückgeben. Für eine leere Zeichenfolge sollte die Methode 0 zurückgeben.

Den Test schreiben

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie die folgenden Testfälle hinzu, um alle Szenarien abzudecken:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Umsetzung des Kodex

Aktualisieren Sie nun die Add-Methode in der Datei string_calculator.py, um die Addition einer oder zweier Zahlen zu verarbeiten:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Sie können den Code erneut testen, indem Sie die vorherigen Schritte ausführen.

Schritt 3: Umgang mit mehreren Nummern

Wir schreiben einen Testfall, um zu prüfen, ob die Methode mehrere durch Kommas getrennte Zahlen verarbeiten kann.

Den Test schreiben

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie einen Testfall zur Verarbeitung mehrerer Zahlen hinzu:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Die Funktionalität wurde bereits implementiert, sodass wir mit dem Testen des Codes fortfahren und dann mit dem nächsten Schritt fortfahren können.

Schritt 4: Umgang mit neuen Zeilen zwischen Zahlen

Jetzt müssen wir die Add-Methode erweitern, um neue Zeilen (n) zusätzlich zu Kommas als gültige Trennzeichen zwischen Zahlen zu verarbeiten.

Den Test schreiben

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie einen Testfall hinzu, um zu überprüfen, ob die Methode neue Zeilen korrekt als Trennzeichen behandelt:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Umsetzung des Kodex

Aktualisieren Sie als Nächstes die Add-Methode in der Datei string_calculator.py, um neue Zeilen (n) als Trennzeichen zu behandeln. Wir können die Methode ändern, um n durch Kommas zu ersetzen und dann die Zeichenfolge durch Kommas aufzuteilen.

Hier ist der aktualisierte Code für die Add-Methode:

python -m unittest discover tests

Sie können den Code erneut testen, indem Sie die vorherigen Schritte ausführen, die in Schritt1 definiert sind.

Schritt 5: Umgang mit benutzerdefinierten Trennzeichen

In diesem Schritt werden wir die Funktionalität weiter verbessern, um benutzerdefinierte Trennzeichen zu ermöglichen. Beispielsweise sollten Benutzer in der Lage sein, am Anfang der Zeichenfolge ein benutzerdefiniertes Trennzeichen anzugeben. Zum Beispiel:

• Die Eingabezeichenfolge könnte mit // gefolgt von einem benutzerdefinierten Trennzeichen beginnen, z. B. //;n1;2;3 sollte 6 zurückgeben.
• Wir unterstützen Trennzeichen wie //;n1;2;3.

Den Test schreiben

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie einen Testfall hinzu, um die benutzerdefinierte Trennzeichenfunktion zu verarbeiten:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Umsetzung des Kodex

Um benutzerdefinierte Trennzeichen zu verarbeiten, aktualisieren Sie die Add-Methode, um nach dem Trennzeichen in der Eingabezeichenfolge zu suchen. Das Trennzeichen sollte am Anfang der Zeichenfolge nach //.

angegeben werden

Hier ist die aktualisierte Add-Methode:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Schritt 6: Umgang mit negativen Zahlen

In diesem Schritt müssen wir die Add-Methode ändern, um negative Zahlen zu verarbeiten. Wenn eine negative Zahl übergeben wird, sollte eine Ausnahme mit der Meldung „Negative Zahlen nicht zulässig“ ausgelöst werden und die übergebenen negativen Zahlen enthalten.

Den Test schreiben

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie einen Testfall hinzu, um die Ausnahme bei negativen Zahlen zu behandeln:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Umsetzung des Kodex

Ändern Sie nun die Add-Methode, um nach negativen Zahlen zu suchen und einen ValueError mit der entsprechenden Meldung auszulösen.

Hier ist die aktualisierte Add-Methode:

def test_add_multiple_numbers(self):
    """
    Test case: Adding multiple numbers should return their sum.
    Input: "1,2,3,4,5"
    Expected Output: 15
    """
    self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)

Schritt 7: Add-Methodenaufrufe zählen

In diesem Schritt fügen wir der StringCalculator-Klasse eine Methode namens GetCalledCount() hinzu, die zurückgibt, wie oft die add()-Methode aufgerufen wurde. Wir folgen dem TDD-Prozess, indem wir zunächst einen fehlgeschlagenen Test schreiben und dann die Funktion implementieren.

Den Test schreiben

Fügen Sie zunächst einen Testfall für die GetCalledCount()-Methode hinzu. Dieser Test sollte überprüfen, ob die Methode korrekt zählt, wie oft add() aufgerufen wird.

Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie den folgenden Test hinzu:

import unittest
from string_calculator import StringCalculator

class TestStringCalculator(unittest.TestCase):
    """Test suite for the StringCalculator class."""

    def setUp(self):
        """
        Create a new instance of StringCalculator for each test.
        Can use static method to avoid creating a new instance.
        """
        self.calculator = StringCalculator()

    def test_empty_string_returns_zero(self):
        """
        Test case: Adding an empty string should return 0.
        Input: "" 
        Expected Output: 0
        """
        self.assertEqual(self.calculator.add(""), 0)

Umsetzung des Kodex

Implementieren Sie nun die Methode GetCalledCount() in der Klasse StringCalculator. Diese Methode muss nachverfolgen, wie oft add() aufgerufen wurde.

Hier ist die aktualisierte StringCalculator-Klasse:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0

Schritt 8 und 9: Ignorieren Sie Zahlen größer als 1000 und verarbeiten Sie benutzerdefinierte Trennzeichen beliebiger Länge

In diesem Schritt werden wir zwei Anforderungen umsetzen:

1. Zahlen größer als 1000 sollten in der Summe ignoriert werden.
2. Benutzerdefinierte Trennzeichen können eine beliebige Länge haben, mit dem Format //[delimiter]n, und die Methode sollte sie verarbeiten.

Wir werden zunächst die Tests für diese beiden Anforderungen schreiben und dann die Funktionalität in der StringCalculator-Klasse implementieren.

Schreiben der Tests

Fügen Sie die folgenden Tests sowohl für das Ignorieren von Zahlen größer als 1000 als auch für die Verarbeitung benutzerdefinierter Trennzeichen beliebiger Länge hinzu. Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie Folgendes hinzu:

python -m unittest discover tests

Umsetzung des Kodex

Implementieren Sie nun die Funktionalität in der StringCalculator-Klasse. Dazu gehört:

1. Zahlen größer als 1000 werden ignoriert.
2. Umgang mit benutzerdefinierten Trennzeichen beliebiger Länge.

Hier ist die aktualisierte StringCalculator-Klasse:

----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Schritt 10: Unterstützung mehrerer Trennzeichen

In diesem Schritt ändern wir die Methode add(), um mehrere Trennzeichen beliebiger Länge zu unterstützen. Dadurch können wir Fälle behandeln, in denen mehrere Trennzeichen im Format //[Trennzeichen1][Trennzeichen2]n.

vorhanden sind

Den Test schreiben

Fügen Sie zunächst einen Testfall hinzu, um zu prüfen, ob mehrere Trennzeichen vorhanden sind. Öffnen Sie die Datei „tests/test_string_calculator.py“ und fügen Sie den folgenden Test hinzu:

    def test_add_single_number(self):
        """
        Test case: Adding a single number should return the number itself.
        Input: "1"
        Expected Output: 1
        """
        self.assertEqual(self.calculator.add("1"), 1)

    def test_add_two_numbers(self):
        """
        Test case: Adding two numbers should return their sum.
        Input: "1,2"
        Expected Output: 3
        """
        self.assertEqual(self.calculator.add("1,2"),3)

Umsetzung des Kodex

Ändern Sie nun die Methode add(), um mehrere Trennzeichen zu verarbeiten. Die Trennzeichen werden innerhalb von [] übergeben, und wir müssen die Verarbeitung mehrerer Trennzeichen im Format //[delimiter1][delimiter2]n.

unterstützen

Hier ist die aktualisierte StringCalculator-Klasse, die dies unterstützt:

class StringCalculator:
    def add(self, numbers:str):
        if not numbers:
            return 0
        '''
        Split the string by commas, convert each value to an integer, 
        and sum them up
        '''
        numbers_list = map(int,numbers.split(',')) 
        return sum(numbers_list)

Testen Sie es

Führen Sie die Tests erneut aus, um sicherzustellen, dass alles funktioniert, einschließlich der Abwärtskompatibilität mit dem alten Format und der Unterstützung für das neue Format mit mehreren Trennzeichen:

def test_add_multiple_numbers(self):
    """
    Test case: Adding multiple numbers should return their sum.
    Input: "1,2,3,4,5"
    Expected Output: 15
    """
    self.assertEqual(self.calculator.add("1,2,3,4,5"), 15)

Erwartete Ausgabe

Die Tests sollten sowohl für alte als auch für neue Formate bestanden werden:

def test_add_numbers_with_newlines(self):
    """
    Test case: Adding numbers separated by newlines should return their sum.
    Input: "1\n2\n3"
    Expected Output: 6
    """
    self.assertEqual(self.calculator.add("1\n2\n3"), 6)

Wir freuen uns, dass Sie dieser TDD-Serie folgen! Ich hoffe, Sie fanden es nützlich.

Das obige ist der detaillierte Inhalt vonErstellen eines String-Rechners mit testgetriebener Entwicklung (TDD): Eine Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!