DocsPricingBlog
Contact Us
Log inSign up for FREE
Back to Tech Articles

Goのnet/httpを使用したモジュラーでテスト可能なWebアプリケーションの構築

Sep 29, 2025
# Misc

Takashi Yamamoto

Infrastructure Engineer · Leapcell

This post is also available in English, 한국어, and Deutsch
Cover of "Goのnet/httpを使用したモジュラーでテスト可能なWebアプリケーションの構築"

はじめに

ソフトウェア開発の急速に進化する状況において、スケーラブルで保守性の高いWebアプリケーションを構築することは最優先事項です。Goは、強力な並行処理プリミティブとシンプルでありながら強力な標準ライブラリを備えており、このための優れた基盤を提供します。多くの場合、開発者は複雑なフレームワークに直接飛び込み、Goのnet/httpパッケージの本来の機能を無視してしまいます。フレームワークは利便性を提供しますが、真の習熟は、多くの場合、基盤となるメカニズムを理解することから生まれます。この記事では、net/httpを活用して、効率的でパフォーマンスが高いだけでなく、設計においてもモジュラーで、容易にテストできるWebアプリケーションを構築する方法を示し、長期的なプロジェクトの成功と容易なコラボレーションへの道を開きます。

堅牢なHTTPアプリケーションのためのコアコンセプト

実装に飛び込む前に、優れたHTTPアプリケーションをGoで構築するための基本的な主要用語について共通の理解を確立しましょう。

  • ハンドラー (Handler): net/httpでは、Handlerは単一のメソッド ServeHTTP(w http.ResponseWriter, r *http.Request) を持つインターフェースです。このメソッドは、受信したHTTPリクエスト(r)を処理し、HTTPレスポンス(w)を送信する責任があります。func(w http.ResponseWriter, r *http.Request)というシグネチャに一致する関数は、http.HandlerFuncを使用して簡単にhttp.Handlerインスタンスに変換できます。
  • ミドルウェア (Middleware): ミドルウェア関数は、他のハンドラーをラップする関数です。これらは、メインハンドラーが実行される前または後に、ログ記録、認証、エラー処理、またはリクエスト/レスポンスヘッダーの変更などのアクションを実行することで、リクエストとレスポンスをインターセプトできます。これはコードの再利用と関心の分離を促進します。
  • ルーティング (Routing): ルーティングは、受信したHTTPリクエスト（URLパス、HTTPメソッドなどに基づいて）を特定のハンドラーにマッピングするプロセスです。net/httpは基本的なルーティング（http.HandleFuncとhttp.ServeMux）を提供しますが、より複雑なアプリケーションでは、ルートを効率的に管理するために、カスタムまたはサードパーティのルーターがよく使用されます。
  • 依存性注入 (Dependency Injection - DI): DIは、コンポーネントが必要とする依存関係（コンポーネントが動作するために必要なオブジェクトまたは関数）が、コンポーネント自体によって作成されるのではなく、コンポーネントに提供されるデザインパターンです。これにより、テスト可能性と柔軟性が大幅に向上します。なぜなら、テスト中に異なる「モック」依存関係を注入できるからです。
  • テスト容易性 (Testability): ソフトウェアをテストできる容易さ。テスト容易性の高いアプリケーションは、多くの場合、疎結合、明確なインターフェース、小さく焦点を絞ったコードユニットの恩恵を受けます。これはまさにモジュラー設計が目指すものです。

モジュラーでテスト可能なWebアプリケーションの構築

私たちの目標は、ユーザー関連のアクション（例：IDによるユーザーの取得）を、構造化され、保守しやすく、テスト可能な方法で処理するWebアプリケーションを作成することです。これを達成するために、コードを明確なモジュールに整理し、Goのインターフェースシステムを活用します。

1. アプリケーション構造の定義

Go Webアプリケーションのための一般的で効果的な構造には、handlers、services（またはusecases）、repositories（またはstores）のようなパッケージに関心の分離を分けることが含まれます。

.
├── cmd/app/main.go        # アプリケーションのエントリーポイント
├── internal/
│   ├── handlers/          # HTTPリクエストハンドラー
│   │   └── user_handler.go
│   ├── models/            # データ構造
│   │   └── user.go
│   ├── services/          # ビジネスロジック
│   │   └── user_service.go
│   └── repositories/      # データアクセスレイヤー
│       └── user_repo.go
└── go.mod
└── go.sum

2. モデル：データ構造の定義

まず、internal/models/user.goで User モデルを定義しましょう。

package models

import "fmt"

type User struct {
	ID    string `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func (u User) String() string {
	return fmt.Sprintf("ID: %s, Name: %s, Email: %s", u.ID, u.Name, u.Email)
}

3. リポジトリ：データアクセスレイヤー（インターフェース付き）

リポジトリパターンは、データストレージメカニズムを抽象化します。インターフェースを定義することで、実装（例：テスト用インメモリ、本番用PostgreSQL）を簡単に切り替えることができます。

internal/repositories/user_repo.go:

package repositories

import (
	"context"
	"errors"
	"fmt"

	"yourproject/internal/models"
)

// ErrUserNotFound は、ユーザーが見つからない場合に返されるエラーです。
var ErrUserNotFound = errors.New("user not found")

// UserRepository は、ユーザーデータ操作のためのインターフェースを定義します。
type UserRepository interface {
	GetUserByID(ctx context.Context, id string) (*models.User, error)
	// CreateUser, UpdateUser, DeleteUserのような他のメソッドを追加
}

// InMemoryUserRepository は、UserRepositoryのシンプルなインメモリ実装です。
type InMemoryUserRepository struct {
	users map[string]*models.User
}

// NewInMemoryUserRepository は、新しいInMemoryUserRepositoryを作成します。
func NewInMemoryUserRepository() *InMemoryUserRepository {
	return &InMemoryUserRepository{
		users: map[string]*models.User{
			"1": {ID: "1", Name: "Alice", Email: "alice@example.com"},
			"2": {ID: "2", Name: "Bob", Email: "bob@example.com"},
		},
	}
}

// GetUserByID は、メモリからIDでユーザーを取得します。
func (r *InMemoryUserRepository) GetUserByID(ctx context.Context, id string) (*models.User, error) {
	// データベース呼び出しの遅延をシミュレート
	// time.Sleep(10 * time.Millisecond)
	if user, ok := r.users[id]; ok {
		return user, nil
	}
	return nil, fmt.Errorf("%w: %s", ErrUserNotFound, id)
}

4. サービス：ビジネスロジックレイヤー（インターフェース付き）

サービスレイヤーには、アプリケーションのコアビジネスロジックが含まれています。リポジトリ間のやり取りを調整し、特定のユースケースを処理します。ここでもインターフェースはテスト容易性を向上させます。

internal/services/user_service.go:

package services

import (
	"context"
	"yourproject/internal/models"
	"yourproject/internal/repositories"
)

// UserService は、ユーザー関連のビジネス操作のためのインターフェースを定義します。
type UserService interface {
	GetUserByID(ctx context.Context, id string) (*models.User, error)
}

// UserServiceImpl は、UserServiceの実装です。
type UserServiceImpl struct {
	userRepo repositories.UserRepository
}

// NewUserService は、新しいUserServiceを作成します。
func NewUserService(repo repositories.UserRepository) *UserServiceImpl {
	return &UserServiceImpl{userRepo: repo}
}

// GetUserByID は、必要なビジネスロジックを実行してIDでユーザーを取得します。
func (s *UserServiceImpl) GetUserByID(ctx context.Context, id string) (*models.User, error) {
	// ここで検証、認可チェックなどを追加できます。
	user, err := s.userRepo.GetUserByID(ctx, id)
	if err != nil {
		// デバッグのためにエラーをログに記録
		// log.Printf("Error getting user by ID %s: %v", id, err)
		return nil, err // エラーを上に渡す
	}
	return user, nil
}

5. ハンドラー：HTTPリクエスト処理

ハンドラーはHTTPリクエストのエントリーポイントです。ビジネスロジックのためにサービスレイヤーに委譲します。json.Marshalとjson.NewDecoderの使用に注意してください。

internal/handlers/user_handler.go:

package handlers

import (
	"encoding/json"
	"log"
	"net/http"

	"yourproject/internal/services"
)

// UserHandler は、ユーザー関連のHTTPリクエストを処理します。
type UserHandler struct {
	userService services.UserService
}

// NewUserHandler は、新しいUserHandlerを作成します。
func NewUserHandler(svc services.UserService) *UserHandler {
	return &UserHandler{userService: svc}
}

// GetUserByID は、IDでユーザーを取得するリクエストを処理します。
// URLパスは /users/{id} のような形式を期待します。
func (h *UserHandler) GetUserByID(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// 基本的な解析：実際のアプリケーションでは、パスパラメータを抽出するルーターを使用します。
	// 簡単にするために、最後のセグメントを手動で解析します。
	id := r.URL.Path[len("/users/"):]
	if id == "" {
		http.Error(w, "User ID is required", http.StatusBadRequest)
		return
	}

	user, err := h.userService.GetUserByID(r.Context(), id)
	if err != nil {
		if err == services.ErrUserNotFound { // 特定のエラーをチェック
			http.Error(w, err.Error(), http.StatusNotFound)
			return
		}
		log.Printf("Error getting user: %v", err) // 内部エラーをログに記録
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	if err := json.NewEncoder(w).Encode(user); err != nil {
		log.Printf("Error encoding response: %v", err)
		http.Error(w, "Internal server error", http.StatusInternalServerError)
	}
}

6. アプリケーションのエントリーポイントと配線

cmd/app/main.go の main 関数は、コンポーネントの配線を担当します。

package main

import (
	"log"
	"net/http"
	"time"

	"yourproject/internal/handlers"
	"yourproject/internal/repositories"
	"yourproject/internal/services"
)

func main() {
	// リポジトリの初期化
	userRepo := repositories.NewInMemoryUserRepository()

	// サービスをリポジトリで初期化
	userService := services.NewUserService(userRepo)

	// ハンドラーをサービスで初期化
	userHandler := handlers.NewUserHandler(userService)

	// ルーティングのための新しいServeMuxを作成
	mux := http.NewServeMux()

	// ルートの登録
	// 注意：より高度なルーティングには、ChiやGorilla Muxなどのサードパーティルーターを検討してください。
	// デモンストレーションのために、単純なプレフィックスマッチを使用しています。
	mux.Handle("/users/", http.HandlerFunc(userHandler.GetUserByID))

	// ミドルウェアの適用（オプションですが、クロスに関わる懸念事項には推奨されます）
	wrappedMux := loggingMiddleware(mux) // シンプルなロギングミドルウェアを追加

	// HTTPサーバーの設定
	server := &http.Server{
		Addr:         ":8080",
		Handler:      wrappedMux,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  120 * time.Second,
	}

	log.Printf("Server starting on %s", server.Addr)
	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatalf("Server failed to start: %v", err)
	}
}

// loggingMiddleware は、受信したリクエストをログに記録します。
func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)
		log.Printf("[%s] %s %s %s", r.Method, r.RequestURI, time.Since(start), r.RemoteAddr)
	})
}

これで go run cmd/app/main.go で実行し、http://localhost:8080/users/1 または http://localhost:8080/users/3 に GET リクエストを送信してください。

7. テスト容易性

このモジュラー設計の美しさは、テストの容易さにあります。インターフェースと依存性注入のおかげで、依存関係を簡単にモックできます。

internal/services/user_service_test.go:

package services_test

import (
	"context"
	"errors"
	"testing"

	"yourproject/internal/models"
	"yourproject/internal/repositories"
	"yourproject/internal/services" // テスト対象のパッケージをインポート
)

// MockUserRepository は repositories.UserRepository のモック実装です。
type MockUserRepository struct {
	GetUserByIDFunc func(ctx context.Context, id string) (*models.User, error)
}

// GetUserByID はモック関数を呼び出します。
func (m *MockUserRepository) GetUserByID(ctx context.Context, id string) (*models.User, error) {
	if m.GetUserByIDFunc != nil {
		return m.GetUserByIDFunc(ctx, id)
	}
	return nil, errors.New("GetUserByID not implemented") // 不足しているモックのデフォルトパニック
}

func TestUserService_GetUserByID(t *testing.T) {
	// テストケース 1：ユーザーが見つかった
	t.Run("user found", func(t *testing.T) {
		expectedUser := &models.User{ID: "123", Name: "Test User", Email: "test@example.com"}
		mockRepo := &MockUserRepository{
			GetUserByIDFunc: func(ctx context.Context, id string) (*models.User, error) {
				if id == "123" {
					return expectedUser, nil
				}
				return nil, repositories.ErrUserNotFound
			},
		}

		svc := services.NewUserService(mockRepo)
		user, err := svc.GetUserByID(context.Background(), "123")

		if err != nil {
			t.Errorf("Expected no error, got %v", err)
		}
		if user == nil || user.ID != "123" {
			t.Errorf("Expected user ID 123, got %v", user)
		}
	})

	// テストケース 2：ユーザーが見つからない
	t.Run("user not found", func(t *testing.T) {
		mockRepo := &MockUserRepository{
			GetUserByIDFunc: func(ctx context.Context, id string) (*models.User, error) {
				return nil, repositories.ErrUserNotFound
			},
		}

		svc := services.NewUserService(mockRepo)
		_, err := svc.GetUserByID(context.Background(), "unknown")

		if err == nil {
			t.Error("Expected an error, got nil")
		}
		if !errors.Is(err, repositories.ErrUserNotFound) {
			t.Errorf("Expected ErrUserNotFound, got %v", err)
		}
	})
	
	// テストケース 3：リポジトリのエラー
	t.Run("repository error", func(t *testing.T) {
		internalErr := errors.New("database connection failed")
		mockRepo := &MockUserRepository{
			GetUserByIDFunc: func(ctx context.Context, id string) (*models.User, error) {
				return nil, internalErr
			},
		}

		svc := services.NewUserService(mockRepo)
		_, err := svc.GetUserByID(context.Background(), "123")

		if err == nil {
			t.Error("Expected an error, got nil")
		}
		if !errors.Is(err, internalErr) {
			t.Errorf("Expected internal error, got %v", err)
		}
	})
}

ハンドラーの直接テストは、net/http/httptestを使用して行うことができます。

internal/handlers/user_handler_test.go:

package handlers_test

import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"

	"yourproject/internal/handlers"
	"yourproject/internal/models"
	"yourproject/internal/repositories" // 比較のためにリポジトリのエラーをインポート
	"yourproject/internal/services" // 比較のためにサービスのエラーをインポート
)

// MockUserService は services.UserService のモック実装です。
type MockUserService struct {
	GetUserByIDFunc func(ctx context.Context, id string) (*models.User, error)
}

// GetUserByID はモック関数を呼び出します。
func (m *MockUserService) GetUserByID(ctx context.Context, id string) (*models.User, error) {
	if m.GetUserByIDFunc != nil {
		return m.GetUserByIDFunc(ctx, id)
	}
	return nil, errors.New("GetUserByID not implemented") // デフォルト
}

func TestUserHandler_GetUserByID(t *testing.T) {
	// テストケース 1：ユーザーが見つかった
	t.Run("user found", func(t *testing.T) {
		expectedUser := &models.User{ID: "1", Name: "Alice", Email: "alice@example.com"}
		mockService := &MockUserService{
			GetUserByIDFunc: func(ctx context.Context, id string) (*models.User, error) {
				if id == "1" {
					return expectedUser, nil
				}
				return nil, services.ErrUserNotFound // リポジトリ経由でエクスポートされたサービスエラーを使用
			},
		}

		handler := handlers.NewUserHandler(mockService)
		req := httptest.NewRequest(http.MethodGet, "/users/1", nil)
		rec := httptest.NewRecorder()

		handler.GetUserByID(rec, req)

		if rec.Code != http.StatusOK {
			t.Errorf("Expected status %d, got %d", http.StatusOK, rec.Code)
		}

		var actualUser models.User
		if err := json.NewDecoder(rec.Body).Decode(&actualUser); err != nil {
			t.Fatalf("Failed to decode response: %v", err)
		}
		if actualUser.ID != expectedUser.ID || actualUser.Name != expectedUser.Name {
			t.Errorf("Expected user %+v, got %+v", expectedUser, actualUser)
		}
	})

	// テストケース 2：ユーザーが見つからない
	t.Run("user not found", func(t *testing.T) {
		mockService := &MockUserService{
			GetUserByIDFunc: func(ctx context.Context, id string) (*models.User, error) {
				return nil, repositories.ErrUserNotFound // ハンドラーのためにベースエラーを直接使用
			},
		}

		handler := handlers.NewUserHandler(mockService)
		req := httptest.NewRequest(http.MethodGet, "/users/99", nil)
		rec := httptest.NewRecorder()

		handler.GetUserByID(rec, req)

		if rec.Code != http.StatusNotFound {
			t.Errorf("Expected status %d, got %d", http.StatusNotFound, rec.Code)
		}
		if rec.Body.String() != "user not found: 99\n" && rec.Body.String() != "user not found\n" { // エラーの伝達方法による
			t.Errorf("Expected 'user not found', got '%s'", rec.Body.String())
		}
	})

	// テストケース 3：無効なメソッド
	t.Run("invalid method", func(t *testing.T) {
		mockService := &MockUserService{} // 実際のサービスロジックは不要
		handler := handlers.NewUserHandler(mockService)
		req := httptest.NewRequest(http.MethodPost, "/users/1", nil)
		rec := httptest.NewRecorder()

		handler.GetUserByID(rec, req)

		if rec.Code != http.StatusMethodNotAllowed {
			t.Errorf("Expected status %d, got %d for POST request", http.StatusMethodNotAllowed, rec.Code)
		}
	})
}

これらのテストは、実際のデータベースや外部サービスを必要とせずに、ビジネスロジックとHTTP処理を独立してテストするために、実際の依存関係と同じインターフェースを実装するモックオブジェクトを簡単に作成できることを示しています。

アプリケーションシナリオ

このモジュラーアプローチは、以下に最適です。

  • RESTful API: リソース管理のための明確に構造化されたエンドポイント。
  • マイクロサービス: 各サービスは、スタンドアロンのモジュラーアプリケーションにすることができます。
  • コードベースの成長: 既存のコードを中断することなく、新しいパッケージで新機能を追加でき、保守性が向上します。
  • 共同開発: 異なるチームが、明確な境界により、最小限のマージコンフリクトで異なるサービスまたはレイヤーで作業できます。

結論

Goの net/http を使用してモジュラーでテスト可能なWebアプリケーションを構築することは、単に可能であるだけでなく、堅牢で、保守しやすく、検証可能なシステムを生み出す強力なアプローチです。インターフェース、依存性注入、レイヤー化されたアーキテクチャを採用することで、開発者は理解しやすく、拡張しやすく、そして最も重要なことにテストしやすいアプリケーションを作成できます。Goの設計哲学から直接得られるこの生来のシンプルさと明瞭さは、あなたのアプリケーションを永続的な成功へと位置づけます。

Share this article

HackerNews

More Posts from Leapcell

Popular Posts