Lerninhalte finden
Schule 
Studium Features
Karteikarten 
StudySmarter AI 
Notizen 
Lernplan 
Spaced Repetition 
Lernsets Entdecke
Lerninhalte finden
Features
Entdecke
© StudySmarter 2025, all rights reserved.
Du bist beauftragt, eine Software-Teststrategie für ein neues Online-Banking-System zu entwickeln. Dein Ziel ist es, sicherzustellen, dass das System fehlerfrei und sicher funktioniert. Dabei sollst Du verschiedene Testarten wie Unit-Tests, Integrationstests und Systemtests berücksichtigen.
Erkläre, wie Unit-Tests für das Online-Banking-System implementiert werden könnten. In Deiner Erklärung sollst Du folgende Punkte berücksichtigen:
Lösung:
Finde einen Job 
Finde dein Studium 
Studentenrabatte 
Ausbildungen 
Magazine 
Mobile App 
Für Unternehmen import unittestclass BankAccount: def __init__(self, account_id, owner, initial_balance=0.0): self.account_id = account_id self.owner = owner self.balance = initial_balance def get_account_details(self): return { 'account_id': self.account_id, 'owner': self.owner, 'balance': self.balance }class TestBankAccountCreation(unittest.TestCase): def test_create_new_account(self): # Arrange account_id = '1234567890' owner = 'John Doe' initial_balance = 1000.0 # Act account = BankAccount(account_id, owner, initial_balance) account_details = account.get_account_details() # Assert self.assertEqual(account_details['account_id'], account_id) self.assertEqual(account_details['owner'], owner) self.assertEqual(account_details['balance'], initial_balance)if __name__ == '__main__': unittest.main() In diesem Beispiel enthält die Klasse BankAccount eine Methode zur Kontoerstellung sowie eine Methode zur Abfrage der Kontodetails. Der Unit-Test in der Klasse TestBankAccountCreation überprüft, ob bei der Erstellung eines neuen Bankkontos die übergebenen Parameter korrekt gesetzt wurden und ob die Funktion zur Abfrage der Kontodetails die erwarteten Werte zurückgibt.Beschreibe den Ansatz für Integrationstests und Systemtests für das Online-Banking-System:
Lösung:
Sie sind der Qualitätssicherungsingenieur für ein Softwaresystem, das zur Berechnung der monatlichen Raten für ein Darlehen verwendet wird. Das System nimmt drei Eingaben an: den Darlehensbetrag (in Euro), die Laufzeit des Darlehens (in Monaten) und den jährlichen Zinssatz (in Prozent). Sie müssen sicherstellen, dass das System die Anforderungen korrekt erfüllt, indem Sie Äquivalenzklassen- und Grenzwertanalysen anwenden.
1. Betrachten Sie den Darlehensbetrag, der Werte im Bereich 1.000 Euro bis 1.000.000 Euro annehmen kann, die Laufzeit des Darlehens, die zwischen 12 und 360 Monaten liegt, und den Zinssatz, der zwischen 1% und 25% variiert. Teilen Sie den Eingabebereich für jede dieser drei Eingaben in Äquivalenzklassen auf und identifizieren Sie mindestens eine Äquivalenzklasse pro Eingabezustand.
Lösung:
2. Für jede Ihrer identifizierten Äquivalenzklassen führen Sie eine Grenzwertanalyse durch. Geben Sie mindestens zwei Testfälle pro Äquivalenzklasse an (einen am unteren und einen am oberen Rand). Berücksichtigen Sie dabei auch die Rand- und Extremwerte jeder Klasse.
Lösung:
Du arbeitest als Software-Tester und bist beauftragt, sowohl Black-Box- als auch White-Box-Testing-Methoden auf eine neu entwickelte Anwendung anzuwenden. Diese Anwendung berechnet den Nettopreis basierend auf der Anzahl der gekauften Artikel und einem festgelegten Preis pro Artikel. Es wird auch ein Discount gewährt, wenn die Anzahl der gekauften Artikel eine bestimmte Schwelle überschreitet.
Nutze die Äquivalenzklassenbildung und die Grenzwertanalyse, um geeignete Black-Box-Testfälle für die oben beschriebene Anwendung zu entwerfen. Erkläre jeweils, warum du jeden Testfall ausgewählt hast.
Lösung:
Um geeignete Black-Box-Testfälle für die Anwendung zu entwerfen, die den Nettopreis basierend auf der Anzahl der gekauften Artikel und einem festgelegten Preis pro Artikel berechnet und gegebenenfalls einen Rabatt gewährt, nutzen wir die Äquivalenzklassenbildung und die Grenzwertanalyse. Mithilfe dieser Methoden lassen sich systematische und vollständige Testfälle entwickeln.
Durch diese Kombination von Äquivalenzklassenbildung und Grenzwertanalyse können wir sicherstellen, dass die Anwendung unter verschiedenen Eingabebedingungen korrekt funktioniert. Jeder Testfall repräsentiert eine spezifische Bedingung, die in der Praxis auftreten könnte, und soll sicherstellen, dass sowohl normale als auch extreme Nutzungsszenarien abgedeckt werden.
Analysiere die Kontrollflüsse der Anwendung und entwirf einen White-Box-Testfall, der die Pfadabdeckung maximiert. Erläutere, welche Pfade du identifiziert hast und wie dein Testfall diese abdeckt.
Lösung:
Um einen White-Box-Testfall zu entwerfen, der die Pfadabdeckung maximiert, müssen wir die Kontrollflüsse der Anwendung analysieren, die den Nettopreis basierend auf der Anzahl der gekauften Artikel und einem festgelegten Preis pro Artikel berechnet und gegebenenfalls einen Rabatt gewährt. Folgende Schritte erläutern die Analyse und die daraus abgeleiteten Testfälle:
Die Anwendung folgt einer bestimmten logischen Struktur, die wir durch ein Flussdiagramm oder Pseudocode repräsentieren können. Hier ist eine vereinfachte Darstellung der Anwendung:
if (quantity < discount_threshold) { \t net_price = quantity * price_per_item; } else { \t total_price = quantity * price_per_item; \t discount = total_price * discount_rate; \t net_price = total_price - discount; } Dies ist der Pfad, wenn die Anzahl der gekauften Artikel unter der Rabatt-Schwelle liegt, und daher kein Rabatt gewährt wird.
Dies ist der Pfad, wenn die Anzahl der gekauften Artikel die Rabatt-Schwelle erreicht oder überschreitet, und daher ein Rabatt gewährt wird.
Durch diese Testfälle stellen wir sicher, dass alle möglichen Pfade durch die Anwendung abgedeckt sind. Dabei überprüfen wir die korrekte Berechnung des Nettopreises sowohl für Szenarien ohne Rabatt als auch für Szenarien mit Rabatt.
Angenommen, die Discount-Regel ist, dass ein Discount von 10% gewährt wird, wenn die Anzahl der gekauften Artikel größer oder gleich 100 ist. Schreibe eine Funktion in Python, die diesen Discount berechnet und einen entsprechenden White-Box-Test dafür durchführt. Teste, ob die Funktion den Discount korrekt anwendet, indem du mindestens drei verschiedene Pfade ausführst.
Lösung:
Um die Aufgabe zu lösen, schreiben wir zuerst eine Funktion in Python, die den Nettopreis basierend auf den Anforderungen berechnet. Danach führen wir White-Box-Tests durch, um sicherzustellen, dass die Funktion korrekt arbeitet und alle Pfade abgedeckt sind.
def calculate_net_price(quantity, price_per_item): \t discount_threshold = 100 \t discount_rate = 0.10 \t if quantity >= discount_threshold: \t \t total_price = quantity * price_per_item \t \t discount = total_price * discount_rate \t \t net_price = total_price - discount \t else: \t \t net_price = quantity * price_per_item \t return net_price
Wir führen drei Testfälle durch, um alle wesentlichen Pfade abzudecken:
def test_case_1(): \t quantity = 50 \t price_per_item = 10 \t expected_net_price = 50 * 10 = 500 \t result = calculate_net_price(quantity, price_per_item) \t assert result == expected_net_price, f'Expected {expected_net_price}, but got {result}' def test_case_2(): \t quantity = 100 \t price_per_item = 10 \t total_price = 100 * 10 = 1000 \t discount = total_price * 0.10 = 100 \t expected_net_price = total_price - discount = 900 \t result = calculate_net_price(quantity, price_per_item) \t assert result == expected_net_price, f'Expected {expected_net_price}, but got {result}' def test_case_3(): \t quantity = 150 \t price_per_item = 10 \t total_price = 150 * 10 = 1500 \t discount = total_price * 0.10 = 150 \t expected_net_price = total_price - discount = 1350 \t result = calculate_net_price(quantity, price_per_item) \t assert result == expected_net_price, f'Expected {expected_net_price}, but got {result}' def run_tests(): \t test_case_1() \t test_case_2() \t test_case_3() \t print('All test cases passed!') run_tests() Durch die Ausführung dieser Testfälle stellen wir sicher, dass die Funktion alle relevanten Pfade abdeckt und korrekt funktioniert, indem sie den entsprechenden Discount nur bei einer Menge von 100 oder mehr Artikeln anwendet.
Du bist für die Qualitätssicherung eines komplexen Softwareprojekts verantwortlich. Im Rahmen deines Studiums hast du die Best Practices für die Implementierung von Testskripten kennengelernt. Du sollst nun diese Best Practices in die Praxis umsetzen und verschiedene Aspekte der Testskripte analysieren und bewerten.
Modularität und Isolierung: Du hast zwei Testskripte, testLogin und testRegistration. Beide Skripte prüfen das Anmelde- und Registrierungsmodul deiner Software. Aktuell wird in beiden Skripten die Datenbank initialisiert und am Ende wird die Verbindung wieder geschlossen.
Lösung:
Die Modularität und Isolierung von Testskripten sind entscheidende Faktoren für die Wartbarkeit und Zuverlässigkeit von Softwaretests. Lass uns die genannten Testskripte testLogin und testRegistration analysieren und Verbesserungsmöglichkeiten finden.
Derzeit initialisieren beide Testskripte die Datenbank und schließen die Verbindung am Ende. Diese Vorgehensweise führt zu einigen Problemen hinsichtlich Modularität und Isolierung:
def setup_database_connection(): # Code zur Initialisierung der Datenbankverbindung passdef teardown_database_connection(): # Code zum Schließen der Datenbankverbindung pass# Basisklasse für die Testsclass BaseTest: @staticmethod def setup_method(): setup_database_connection() @staticmethod def teardown_method(): teardown_database_connection()class TestLogin(BaseTest): def test_login_success(self): # Bereite Testdaten vor # Führe Login-Test durch pass def test_login_failure(self): # Bereite Testdaten vor # Führe Login-Test durch passDurch diese Änderungen werden die Testskripte modularer, leichter wartbar und besser isoliert. Dies führt zu zuverlässigerem und effizienterem Testing.
Automatisierung und Fehlerbehandlung: Du implementierst Testskripte mit JUnit. Ein bestimmter Testfall testPaymentProcessing schlägt häufig aufgrund von Netzwerkproblemen fehl.
Lösung:
Um Testskripte robust gegen temporäre Netzwerkfehler zu gestalten, können Wiederholungsmechanismen und eine sinnvolle Fehlerbehandlung implementiert werden. JUnit bietet Möglichkeiten, solche Mechanismen einzubauen, um sicherzustellen, dass Tests nicht sofort wegen flüchtiger Probleme fehlschlagen.
Beschreibung:
Um die testPaymentProcessing-Tests zu automatisieren und robust gegen Netzwerkfehler zu gestalten, könnten die folgenden Schritte unternommen werden:
import static org.junit.jupiter.api.Assertions.*;import org.junit.jupiter.api.RepeatedTest;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;import org.junit.jupiter.api.extension.ExtensionContext;import org.junit.jupiter.api.extension.TestExecutionExceptionHandler;public class PaymentProcessingTest { private static final int MAX_RETRIES = 3; @RepeatedTest(value = MAX_RETRIES) void testPaymentProcessing() { try { // Simuliere Zahlungsprozess processPayment(); } catch (NetworkException e) { // Werfe Ausnahme nur, wenn es sich um den letzten Versuch handelt if (ExtensionContext.getRequiredTestMethod().getParameterCount() == MAX_RETRIES) { throw e; } } } void processPayment() throws NetworkException { // Hier wird der eigentliche Zahlungsprozess implementiert // Zum Beispiel: HTTP-Anfrage an Zahlungs-Gateway senden // Wirf NetworkException bei Netzwerkfehlern } // Benutzerdefinierte Ausnahme für Netzwerkfehler class NetworkException extends Exception { public NetworkException(String message) { super(message); } }}// Erweiterung für das Wiederholen von Tests bei Ausnahmenclass RetryTestExtension implements TestExecutionExceptionHandler { @Override public void handleTestExecutionException(ExtensionContext context, Throwable throwable) throws Throwable { if (context.getExecutionCount() < MAX_RETRIES && throwable instanceof NetworkException) { // Wartezeit einführen, bevor der Test erneut versucht wird Thread.sleep(1000); // Test erneut ausführen context.getTestInstance().get().testPaymentProcessing(); } else { // Ausnahme weiterwerfen, wenn maximale Anzahl an Versuchen erreicht ist throw throwable; } }}Durch diese Implementierung werden temporäre Netzwerkfehler abgefangen, und der Test wird mehrere Male wiederholt, bevor er als fehlgeschlagen markiert wird. Dies erhöht die Zuverlässigkeit des Tests und reduziert die Wahrscheinlichkeit von Flaky Tests, die durch temporäre Netzwerkprobleme verursacht werden.
Dokumentation und Wiederholbarkeit: Im Testprojekt gibt es oft Inkonsistenzen in den Testergebnissen aufgrund unterschiedlicher Testumgebungen. Dies führt zu Problemen bei der Reproduzierbarkeit von Fehlern und ihrer Behebung.
Lösung:
Um die Konsistenz und Wiederholbarkeit von Testergebnissen sicherzustellen, sind eine sorgfältige Dokumentation und eine Strategie zur Handhabung von umgebungsbedingten Inkonsistenzen erforderlich. Hier sind einige Maßnahmen und Strategien, die Du ergreifen kannst:
Durch diese Maßnahmen stellst Du sicher, dass Testergebnisse konsistent und reproduzierbar sind. Dies erleichtert die Fehlersuche und -behebung erheblich und erhöht die Zuverlässigkeit der Qualitätssicherung.
Mit unserer kostenlosen Lernplattform erhältst du Zugang zu Millionen von Dokumenten, Karteikarten und Unterlagen.
Kostenloses Konto erstellenDu hast bereits ein Konto? Anmelden