Testing Mastery: JUnit, Mockito & Integration Tests · บทเรียน

การจัดการข้อมูลทดสอบ

พัฒนากลยุทธ์สำหรับสร้าง จัดการ และล้างข้อมูลทดสอบ เพื่อให้การทดสอบ E2E ทำซ้ำได้ผลลัพธ์เดิม

การจัดการข้อมูลทดสอบ เป็นบทเรียน Testing Mastery: JUnit, Mockito & Integration Tests ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Testing Mastery: JUnit, Mockito & Integration Tests และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Testing Mastery: JUnit, Mockito & Integration Tests มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

E2E Test Data Basics

When performing End-to-End (E2E) tests, test data is crucial. It's the information your application uses during a test, like user accounts, product details, or order histories.

Without good test data, your E2E tests become unreliable. Imagine testing an e-commerce checkout without a product in the cart or a registered user!

Challenges with E2E Data

Managing test data for E2E tests comes with unique challenges:

Complexity: E2E tests often interact with multiple parts of the system, requiring complex data setups.
Dependencies: Data might depend on external systems or other modules, making it hard to control.
Statefulness: Tests can leave the system in an unexpected state, affecting subsequent tests.
Cleanup: Removing data after a test can be tricky but is vital for repeatability.

Create Data via API

A common strategy is to create test data programmatically using your application's own APIs (e.g., REST API endpoints). This ensures the data goes through the same validation logic as real user data.

Try running this example that simulates creating a user via an API:

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws IOException, InterruptedException {
    String jsonPayload = "{\"username\": \"testuser\", \"email\": \"test@example.com\"}";
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/users"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
        .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    System.out.println("API Call Status: " + response.statusCode());
    System.out.println("Response Body: " + response.body());
  }
}

Data with Database Scripts

For some E2E tests, you might need to directly insert data into the database using SQL scripts. This is fast but bypasses your application's business logic.

Use this method carefully, typically for foundational data or when API creation is too slow or complex.

INSERT INTO users (id, username, email)
VALUES (101, 'db_user', 'db@example.com');

INSERT INTO products (id, name, price)
VALUES (201, 'Test Product A', 19.99);

Using Test Data Factories

Test data factories (or generators) are tools or custom classes that automate the creation of realistic, varied data. Libraries like Faker can generate names, addresses, and more.

This helps create diverse test scenarios without manual effort. Here's a simple factory concept:

// Imagine a UserFactory class
class User {
    String username;
    String email;
    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }
    @Override
    public String toString() {
        return "User: " + username + " (" + email + ")";
    }
}

class UserFactory {
    private static int counter = 0;
    public static User createRandomUser() {
        counter++;
        return new User("user_" + counter, "user" + counter + "@example.com");
    }
}

public class Main {
  public static void main(String[] args) {
    User user1 = UserFactory.createRandomUser();
    User user2 = UserFactory.createRandomUser();
    System.out.println(user1);
    System.out.println(user2);
  }
}

Isolate Test Data

One of the most important principles is test data isolation. Each test or test suite should ideally operate on its own, unique set of data.

This prevents tests from interfering with each other, making them more reliable and easier to debug. Shared data can lead to flaky tests that pass or fail unpredictably.

Environment Data

Test data often needs to be different across various environments (e.g., development, staging, production). You might have specific configurations or external service integrations that require unique data.

Manage this by using environment variables, configuration files, or dedicated data sets for each environment.

Crucial Data Cleanup

Creating test data is only half the battle; cleaning it up is just as critical. After a test runs, any data it created should be removed.

Why is cleanup so important?

Ensures tests are truly repeatable.
Prevents data pollution in your test environment.
Avoids unexpected side effects on subsequent tests.

Programmatic Cleanup

Just as you create data programmatically, you should also delete it programmatically. This can involve calling a 'delete' API endpoint or running SQL DELETE statements.

Often, cleanup is performed in a @AfterEach or @AfterAll type method (depending on your testing framework) to guarantee execution after tests complete.

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
  public static void main(String[] args) throws IOException, InterruptedException {
    String userIdToDelete = "testuser"; // Or an ID obtained during creation
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.example.com/users/" + userIdToDelete))
        .DELETE()
        .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    System.out.println("Delete Status: " + response.statusCode());
  }
}

Test Data Quiz

Which of the following are good practices for managing test data in End-to-End (E2E) tests?

Recap: Test Data Mastery

You've learned that effective test data management is vital for stable and repeatable E2E tests. We covered:

Strategies for creating data (APIs, DB scripts, factories).
The importance of data isolation and environment-specific data.
The necessity of cleaning up data after tests.

By applying these strategies, you can build more robust and reliable E2E testing suites!

คำถามที่พบบ่อย

บทเรียน “การจัดการข้อมูลทดสอบ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจัดการข้อมูลทดสอบ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Testing Mastery: JUnit, Mockito & Integration Tests ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Testing Mastery: JUnit, Mockito & Integration Tests มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การจัดการข้อมูลทดสอบ”

พัฒนากลยุทธ์สำหรับสร้าง จัดการ และล้างข้อมูลทดสอบ เพื่อให้การทดสอบ E2E ทำซ้ำได้ผลลัพธ์เดิม คุณปฏิบัติ Testing Mastery: JUnit, Mockito & Integration Tests ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Testing Mastery: JUnit, Mockito & Integration Tests หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Testing Mastery: JUnit, Mockito & Integration Tests บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การจัดการข้อมูลทดสอบ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Testing Mastery: JUnit, Mockito & Integration Tests นี้ได้ไหม

ได้ บทเรียน Testing Mastery: JUnit, Mockito & Integration Tests ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การทดสอบ E2E เทียบกับการทดสอบการผสานรวม
ภาพรวมเครื่องมือทดสอบ E2E
การจัดการข้อมูลทดสอบ
การเขียนการทดสอบ E2E ที่เชื่อถือได้: กำจัดความไม่แน่นอน

← กลับไปที่ Testing Mastery: JUnit, Mockito & Integration Tests