0Pricing
Clean Architecture & Design Patterns in Practice · レッスン

Presentation層のテスト

UIロジックの堅牢性と独立性を確保するため、Presentation層の効果的なテスト戦略を構築します。

「Presentation層のテスト」はCoddyKit上の無料Clean Architecture & Design Patterns in Practiceレッスンです。 これはレッスン3/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはClean Architecture & Design Patterns in Practice学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Clean Architecture & Design Patterns in Practiceコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

Intro to Presentation Layer Testing

In Clean Architecture, the presentation layer is responsible for preparing data for the user interface (UI). It acts as an adapter, translating the application's core data into a format that's easy for the UI to display.

This lesson focuses on testing the logic within this layer, ensuring it's robust and independent of the actual UI framework.

Why Decouple UI Logic Tests?

Testing the presentation layer independently offers several key advantages:

  • Faster Feedback: Unit tests run quickly, giving immediate feedback on logic changes.
  • Isolation: Bugs in presentation logic are easier to pinpoint without needing to interact with a full UI.
  • Robustness: Ensures the data transformation and display rules are correctly applied, regardless of the UI framework used.

What to Test: Presenters & View Models

Within the presentation layer, our primary focus for unit testing will be on two components:

  • Presenters: These orchestrate the data flow, taking output from Use Cases and transforming it.
  • View Models: Simple data structures specifically designed to hold data that the UI needs to display, formatted for presentation.

Unit Testing Presenter Logic

A Presenter receives data from a Use Case and decides how to prepare it for the view. It doesn't interact directly with the UI elements, but rather with a view interface.

When testing a Presenter, we want to verify that it correctly:

  • Transforms the Use Case's data into a View Model.
  • Calls the appropriate method on the view interface with the correct View Model.

Presenter Structure Example

Consider a simple UserPresenter that takes a UserResponse (from a Use Case) and creates a UserViewModel to be displayed by a UserView interface. We test the Presenter's internal logic.

/* User.java */
class User {
  String name;
  User(String name) { this.name = name; }
  String getName() { return name; }
}

/* UserResponse.java (from Use Case) */
class UserResponse {
  User user;
  UserResponse(User user) { this.user = user; }
  User getUser() { return user; }
}

/* UserViewModel.java (for UI) */
class UserViewModel {
  String displayName;
  UserViewModel(String name) { this.displayName = name; }
  String getDisplayName() { return displayName; }
}

/* UserView.java (interface for UI) */
interface UserView {
  void displayUser(UserViewModel viewModel);
}

/* UserPresenter.java */
class UserPresenter {
  private UserView view;
  UserPresenter(UserView view) { this.view = view; }

  void presentUser(UserResponse response) {
    String userName = response.getUser().getName();
    UserViewModel viewModel = new UserViewModel("Welcome, " + userName + "!");
    view.displayUser(viewModel);
  }
}

Testing a Basic Presenter

Here's how you might test the UserPresenter. We simulate the UserResponse and create a "mock" UserView to verify the Presenter's interaction.

Try running this example:

/* User.java (omitted for brevity, see previous scene) */
/* UserResponse.java (omitted for brevity) */
/* UserViewModel.java (omitted for brevity) */
/* UserView.java (omitted for brevity) */
/* UserPresenter.java (omitted for brevity) */

public class Main {
  public static void main(String[] args) {
    System.out.println("--- Presenter Test Simulation ---");

    // 1. Prepare test data (input to Presenter)
    User mockUser = new User("Alice");
    UserResponse mockResponse = new UserResponse(mockUser);

    // 2. Create a mock for the view interface
    //    This mock will let us check if displayUser was called correctly.
    UserView mockView = new UserView() {
      @Override
      public void displayUser(UserViewModel viewModel) {
        System.out.println("Mock View received ViewModel: " + viewModel.getDisplayName());
        // 3. Assertions (in a real test framework)
        if (viewModel.getDisplayName().equals("Welcome, Alice!")) {
          System.out.println("✔ Presenter transformed data correctly!");
        } else {
          System.out.println("✖ Presenter transformation failed.");
        }
      }
    };

    // 4. Instantiate the Presenter with the mock view
    UserPresenter presenter = new UserPresenter(mockView);

    // 5. Execute the method under test
    presenter.presentUser(mockResponse);
  }
}

Validating View Model Data

View Models are usually simpler than Presenters. They are often plain data classes that hold the formatted information to be displayed directly by the UI.

Testing View Models primarily involves ensuring that they correctly encapsulate and format the data they receive from the Presenter or other sources.

View Model Structure Example

A ProductViewModel might take a raw Product object and format its name and price into display-ready strings. Its job is just to hold this display-ready data.

/* Product.java (raw data from domain) */
class Product {
  String name;
  double price;
  Product(String name, double price) {
    this.name = name;
    this.price = price;
  }
  String getName() { return name; }
  double getPrice() { return price; }
}

/* ProductViewModel.java (display data for UI) */
class ProductViewModel {
  String displayName;
  String displayPrice;

  ProductViewModel(Product product) {
    this.displayName = product.getName().toUpperCase();
    this.displayPrice = String.format("$%.2f", product.getPrice());
  }

  String getDisplayName() { return displayName; }
  String getDisplayPrice() { return displayPrice; }
}

Testing View Model Construction

We test the View Model by providing it with raw data and then asserting that its public properties hold the correctly formatted values. This confirms its internal formatting logic works as expected.

Try running this example:

/* Product.java (omitted for brevity, see previous scene) */
/* ProductViewModel.java (omitted for brevity) */

public class Main {
  public static void main(String[] args) {
    System.out.println("--- View Model Test Simulation ---");

    // 1. Prepare raw data (input to ViewModel constructor)
    Product product = new Product("Laptop", 1200.50);

    // 2. Instantiate the ViewModel
    ProductViewModel viewModel = new ProductViewModel(product);

    // 3. Assertions (in a real test framework)
    System.out.println("Checking ViewModel content:");
    boolean nameCorrect = viewModel.getDisplayName().equals("LAPTOP");
    boolean priceCorrect = viewModel.getDisplayPrice().equals("$1200.50");

    if (nameCorrect) {
      System.out.println("✔ Display Name: '" + viewModel.getDisplayName() + "' is correct.");
    } else {
      System.out.println("✖ Display Name: Expected 'LAPTOP', got '" + viewModel.getDisplayName() + "'.");
    }

    if (priceCorrect) {
      System.out.println("✔ Display Price: '" + viewModel.getDisplayPrice() + "' is correct.");
    } else {
      System.out.println("✖ Display Price: Expected '$1200.50', got '" + viewModel.getDisplayPrice() + "'.");
    }

    if (nameCorrect && priceCorrect) {
      System.out.println("All ViewModel transformations worked!");
    } else {
      System.out.println("Some ViewModel transformations failed.");
    }
  }
}

Mocking Dependencies for Isolation

A key technique in unit testing the presentation layer (especially Presenters) is mocking.

  • What it is: Creating simulated objects that mimic the behavior of real dependencies (like a UserView).
  • Why it's used: It allows us to isolate the component being tested, ensuring our test fails only if the component itself has a bug, not its dependencies.
  • How it helps: We can verify interactions (e.g., if a method was called) without needing a full, functional dependency.

Test Your Knowledge

Which components are primarily unit tested within the Clean Architecture's presentation layer to ensure UI logic is robust and independent?

Recap: Testing Presentation Logic

Congratulations! You've learned how to effectively test the presentation layer in Clean Architecture.

  • We focused on unit testing Presenters to verify data transformation and interaction with view interfaces.
  • We also covered testing View Models to ensure data is correctly formatted for display.
  • The importance of mocking was highlighted for isolating components and making tests reliable.

By applying these strategies, you ensure your UI logic is robust, maintainable, and truly independent.

よくある質問

「Presentation層のテスト」レッスンは無料ですか？

はい。「Presentation層のテスト」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Clean Architecture & Design Patterns in Practiceコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Clean Architecture & Design Patterns in Practiceコースには全4レッスンが含まれています。

「Presentation層のテスト」で何を学びますか？

UIロジックの堅牢性と独立性を確保するため、Presentation層の効果的なテスト戦略を構築します。 ブラウザで直接実行するハンズオンコードでClean Architecture & Design Patterns in Practiceを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Clean Architecture & Design Patterns in Practiceを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのClean Architecture & Design Patterns in Practiceは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン3/4です。

「Presentation層のテスト」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このClean Architecture & Design Patterns in Practiceレッスンでコードを書いて実行できますか？

はい。すべてのClean Architecture & Design Patterns in Practiceレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. PresentersとView Models
  2. Webフレームワークへの適応
  3. Presentation層のテスト
  4. Humble Objectとビューの境界
← Clean Architecture & Design Patterns in Practiceに戻る