TODOリストAPIの実装タスク分解

[Nao-Mk2]

前提条件

• Go言語を利用する。
• ディレクトリ構成は https://go.dev/doc/modules/layout を参考にする。
• テスト駆動開発を行う。

要件

• TODOリストを管理するWeb APIサーバーを実装する。
• TODOアイテムは以下のフィールドを持つ。
  • ID: int
  • タイトル: string
  • 期限: time.Time
• TODOアイテムはメモリ上に保持する。
• /todo/{{id}} にGETリクエストをすると、指定したIDのTODOアイテムを取得する。
• /todo にPOSTリクエストをすると、指定したIDのTODOアイテムを作成する。
  • レスポンスボディは以下のJSON形式とする。

    {
      "id": 1, // ID
      "title": "タイトル", // タイトル
      "due_date": "期限" // 期限(RFC3339形式)
    }
    

タスク分解

1. プロジェクト初期設定

• Go モジュールの初期化
• 必要なパッケージのインストール

2. モデル層の実装

• TODOアイテムの構造体定義
• メモリ上でTODOアイテムを管理するリポジトリの実装
• リポジトリのテスト実装

3. サービス層の実装

• TODOアイテムの作成と取得のビジネスロジック実装
• サービス層のテスト実装

4. ハンドラー層の実装

• HTTPリクエストを処理するハンドラーの実装
• ハンドラーのテスト実装

5. メインアプリケーションの実装

• HTTPサーバーの設定と起動
• ルーティングの設定

6. 動作確認

• 手動テストによる動作検証

ディレクトリ構成例

/
├── cmd/
│   └── server/
│       └── main.go               # アプリケーションのエントリーポイント
├── internal/
│   ├── domain/
│   │   └── todo.go               # TODOアイテムのドメインモデル
│   ├── repository/
│   │   ├── todo_repository.go    # TODOアイテムのリポジトリインターフェース
│   │   ├── memory/
│   │   │   ├── todo_repository.go  # メモリ上に保持するリポジトリの実装
│   │   │   └── todo_repository_test.go  # リポジトリのテスト
│   ├── service/
│   │   ├── todo_service.go       # TODOサービスのインターフェース
│   │   ├── todo_service_impl.go  # TODOサービスの実装
│   │   └── todo_service_test.go  # サービスのテスト
│   └── handler/
│       ├── todo_handler.go       # HTTPハンドラー
│       └── todo_handler_test.go  # ハンドラーのテスト
├── pkg/
│   └── utils/                    # 汎用的なユーティリティ関数
├── go.mod                        # Go モジュール定義
├── go.sum                        # 依存関係のチェックサム
└── README.md                     # プロジェクトの説明

[Nao-Mk2]

[プロンプトのメモ]

1. プロジェクト初期設定のステップ

Nao-Mk2: #2のissueの「1. プロジェクト初期設定」を実行して。

---

GitHub Copilot: GitHub Copilot としてお手伝いします。まず、#2のissueの内容を確認しましょう。issue #2の内容を確認しました。「1. プロジェクト初期設定」のタスクを実行します。これには以下のステップが含まれています：

• Go モジュールの初期化
• 必要なパッケージのインストール

まず、ディレクトリ構成を作成し、Go モジュールを初期化します。ディレクトリ構造を作成しました。次に、Goモジュールを初期化します。Go モジュールの初期化が完了しました。次に、このTODO APIに必要なパッケージをインストールします。HTTPサーバーの実装には標準ライブラリのnet/httpを使用し、JSONのエンコード・デコードにはencoding/jsonを使用します。また、ルーティングのためにgithub.com/gorilla/muxを使用すると便利です。

それでは、必要なパッケージをインストールしましょう：ディレクトリ構造の作成とGoモジュールの初期化が完了しました。また、HTTPルーティングライブラリであるgithub.com/gorilla/muxをインストールしました。

これでプロジェクトの初期設定が整いました。以下の内容が設定されています：

1. 必要なディレクトリ構造を作成済み：

   • server：アプリケーションのエントリーポイント用
   • domain：TODOアイテムのドメインモデル用
   • memory：リポジトリの実装用
   • service：サービス層の実装用
   • handler：HTTPハンドラー用
   • utils：汎用ユーティリティ関数用

2. Goモジュールを初期化済み：

   • モジュール名：github.com/Nao-Mk2/nao_github_copilot_lab

3. 必要なパッケージをインストール済み：

   • github.com/gorilla/mux：HTTPルーティングライブラリ

次のステップとしては、issue #2の「2. モデル層の実装」に進むことができます。これには以下が含まれます：

• TODOアイテムの構造体定義
• メモリ上でTODOアイテムを管理するリポジトリの実装
• リポジトリのテスト実装

必要であれば、その実装に進みますが、いかがでしょうか？

---

Nao-Mk2: 各ディレクトリ配下に .keep ファイルを追加して。

---

GitHub Copilot: 各ディレクトリに .keep ファイルを追加します。これは空のディレクトリをGitリポジトリで追跡できるようにするための一般的な方法です。

まず、どのディレクトリに .keep ファイルが必要かを確認してみましょう。各ディレクトリに .keep ファイルを追加していきます。まずは全てのサブディレクトリを確認してから作業を進めます。

ルートディレクトリ配下のサブディレクトリとして cmd、internal、pkg があることを確認しました。それぞれのディレクトリの配下にも .keep ファイルを追加する必要があります。

以下のコマンドを実行して、各ディレクトリに .keep ファイルを作成します：ディレクトリ一覧が取得できました。以下のすべてのディレクトリに .keep ファイルを追加していきます：

1. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/cmd/server
2. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/internal/domain
3. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/internal/handler
4. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/internal/repository/memory
5. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/internal/service
6. /Users/Nao-Mk2/git/Nao-Mk2/nao_github_copilot_lab/pkg/utils

それでは、各ディレクトリに .keep ファイルを作成します：各ディレクトリに .keep ファイルを追加しました。以下のディレクトリすべてに .keep ファイルが作成されました：

• cmd/server/
• internal/domain/
• internal/handler/
• internal/repository/memory/
• internal/service/
• pkg/utils/

これで、Gitでリポジトリを管理する際に、これらの空のディレクトリも追跡対象となります。空のディレクトリはGitでは通常追跡されませんが、.keep ファイルを配置することで、そのディレクトリ構造をリポジトリに含めることができます。

これで指示された作業は完了しました。今後コードを追加していく際も、この整理されたディレクトリ構造に沿って実装していくことができます。他に必要な作業があればお知らせください。

2. モデル層の実装

Nao-Mk2: #2のissueの「2. モデル層の実装」を実行して。

---

GitHub Copilot: 「#2のissueの「2. モデル層の実装」を実行して」というリクエストを受け取りました。まず、このissueの内容を確認してみましょう。issueの内容を確認しました。Issue #2では「TODOリストAPIの実装タスク分解」が記載されており、その中の「2. モデル層の実装」を行う必要があります。

このタスクには以下の内容が含まれています：

1. TODOアイテムの構造体定義
2. メモリ上でTODOアイテムを管理するリポジトリの実装
3. リポジトリのテスト実装

それでは、順番に実装していきましょう。

まず、TODOアイテムの構造体を定義するファイルを作成します：

package domain

import (
	"time"
)

// Todo はTODOアイテムを表す構造体です
type Todo struct {
	ID      int       `json:"id"`
	Title   string    `json:"title"`
	DueDate time.Time `json:"due_date"`
}

Made changes.

次に、TODOリポジトリのインターフェースを定義します。このインターフェースは、TODOアイテムの取得と作成のメソッドを持ちます：

package repository

import (
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
)

// TodoRepository はTODOアイテムのリポジトリのインターフェースです
type TodoRepository interface {
	// GetByID は指定されたIDのTODOアイテムを取得します
	GetByID(id int) (*domain.Todo, error)
	
	// Create は新しいTODOアイテムを作成します
	Create(todo *domain.Todo) (*domain.Todo, error)
}

Made changes.

次に、インメモリで実装したTODOリポジトリを作成します。このリポジトリはメモリ上でTODOアイテムを管理します：

package memory

import (
	"errors"
	"sync"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/repository"
)

var (
	// ErrTodoNotFound はTODOアイテムが見つからない場合のエラーです
	ErrTodoNotFound = errors.New("todo not found")
)

// MemoryTodoRepository はメモリ上でTODOアイテムを管理するリポジトリの実装です
type MemoryTodoRepository struct {
	todos map[int]*domain.Todo
	mutex sync.RWMutex
	nextID int
}

// NewMemoryTodoRepository は新しいMemoryTodoRepositoryのインスタンスを生成します
func NewMemoryTodoRepository() repository.TodoRepository {
	return &MemoryTodoRepository{
		todos:  make(map[int]*domain.Todo),
		nextID: 1,
	}
}

// GetByID は指定されたIDのTODOアイテムを取得します
func (r *MemoryTodoRepository) GetByID(id int) (*domain.Todo, error) {
	r.mutex.RLock()
	defer r.mutex.RUnlock()

	todo, exists := r.todos[id]
	if !exists {
		return nil, ErrTodoNotFound
	}
	return todo, nil
}

// Create は新しいTODOアイテムを作成します
func (r *MemoryTodoRepository) Create(todo *domain.Todo) (*domain.Todo, error) {
	r.mutex.Lock()
	defer r.mutex.Unlock()

	// IDの設定
	todo.ID = r.nextID
	r.nextID++

	// 新しいオブジェクトをマップに追加
	r.todos[todo.ID] = todo

	return todo, nil
}

Made changes.

最後に、リポジトリのテストを実装します。テスト駆動開発の要件を満たすために、単体テストを作成しましょう。

package memory

import (
	"testing"
	"time"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
)

func TestMemoryTodoRepository_Create(t *testing.T) {
	repo := NewMemoryTodoRepository()
	
	// テスト用のTodoアイテムを作成
	dueDate := time.Date(2025, 5, 1, 0, 0, 0, 0, time.UTC)
	todo := &domain.Todo{
		Title:   "テストタスク",
		DueDate: dueDate,
	}
	
	// リポジトリにTodoを作成
	createdTodo, err := repo.Create(todo)
	if err != nil {
		t.Fatalf("Create() error = %v", err)
	}
	
	// 作成されたTodoの検証
	if createdTodo.ID <= 0 {
		t.Errorf("Create() generated ID = %v, want > 0", createdTodo.ID)
	}
	
	if createdTodo.Title != todo.Title {
		t.Errorf("Create() title = %v, want %v", createdTodo.Title, todo.Title)
	}
	
	if !createdTodo.DueDate.Equal(todo.DueDate) {
		t.Errorf("Create() dueDate = %v, want %v", createdTodo.DueDate, todo.DueDate)
	}
}

func TestMemoryTodoRepository_GetByID(t *testing.T) {
	repo := NewMemoryTodoRepository()
	
	// テスト用のTodoアイテムを作成して保存
	dueDate := time.Date(2025, 5, 1, 0, 0, 0, 0, time.UTC)
	todo := &domain.Todo{
		Title:   "テストタスク",
		DueDate: dueDate,
	}
	
	createdTodo, _ := repo.Create(todo)
	
	// 存在するIDのケース
	t.Run("存在するID", func(t *testing.T) {
		fetchedTodo, err := repo.GetByID(createdTodo.ID)
		if err != nil {
			t.Fatalf("GetByID() error = %v", err)
		}
		
		if fetchedTodo.ID != createdTodo.ID {
			t.Errorf("GetByID() ID = %v, want %v", fetchedTodo.ID, createdTodo.ID)
		}
		
		if fetchedTodo.Title != createdTodo.Title {
			t.Errorf("GetByID() title = %v, want %v", fetchedTodo.Title, createdTodo.Title)
		}
		
		if !fetchedTodo.DueDate.Equal(createdTodo.DueDate) {
			t.Errorf("GetByID() dueDate = %v, want %v", fetchedTodo.DueDate, createdTodo.DueDate)
		}
	})
	
	// 存在しないIDのケース
	t.Run("存在しないID", func(t *testing.T) {
		nonExistentID := createdTodo.ID + 1000
		_, err := repo.GetByID(nonExistentID)
		if err != ErrTodoNotFound {
			t.Errorf("GetByID() error = %v, want %v", err, ErrTodoNotFound)
		}
	})
}

Made changes.

テストを実行して、モデル層の実装が正しく動作するか確認しましょう。テストの実行中に問題が発生したようです。修正が必要かもしれません。まず、現在のモジュール名を確認しましょう。テストの実行中に問題が発生したようです。go.modファイルを確認したところ、モジュール名はgithub.com/Nao-Mk2/nao_github_copilot_labと正しく設定されています。

このエラーは、internal/repository/memory/todo_repository_test.goのテスト実行時に発生しています。依存関係を解決するためにテストディレクトリでgo getコマンドを実行してみましょう。先ほどのgo getコマンドが実行されましたが、詳細な結果が表示されませんでした。では次に、テストを再度実行してみましょう。テストが正常に実行され、すべてのテストケースに合格しました。テスト結果は以下の通りです：

• TestMemoryTodoRepository_Create: 正常に完了
• TestMemoryTodoRepository_GetByID/存在するID: 正常に完了
• TestMemoryTodoRepository_GetByID/存在しないID: 正常に完了

これで、Issue #2の「2. モデル層の実装」タスクが完了しました。以下の内容を実装しました：

1. TODOアイテムの構造体定義 (internal/domain/todo.go)

   • ID、タイトル、期限を持つTodo構造体を定義

2. メモリ上でTODOアイテムを管理するリポジトリの実装

   • リポジトリのインターフェース (internal/repository/todo_repository.go)
   • インメモリ実装 (internal/repository/memory/todo_repository.go)

3. リポジトリのテスト実装 (internal/repository/memory/todo_repository_test.go)

   • Create()メソッドのテスト
   • GetByID()メソッドのテスト（存在するID、存在しないIDの両方のケース）

これらの実装により、TODOアイテムをメモリ上で管理し、作成や取得ができるようになりました。次のステップではこの実装を基に、サービス層やハンドラー層を実装していくことができます。

3. サービス層の実装

Nao-Mk2: #2のissueの「3. サービス層の実装」を実行して。

---

GitHub Copilot: 了解しました。まず、#2のissueの内容を確認し、サービス層の実装を行っていきます。issueの内容を確認できました。#2のissueでは「TODOリストAPIの実装タスク分解」が記載されており、現在は「3. サービス層の実装」を行う必要があります。

まず、既存のドメインモデルとリポジトリの実装を確認してから、サービス層を実装していきます。リポジトリの実装も確認してみましょう。メモリ上のリポジトリ実装も確認しておきましょう。既存のファイルの内容を確認しました。ドメインモデルとリポジトリの実装はすでに完了しています。次は、サービス層の実装を行っていきます。

サービス層では、リポジトリからのデータ取得とビジネスロジックを担当します。サービス層には以下のファイルを作成する必要があります：

1. internal/service/todo_service.go - サービスのインターフェース
2. internal/service/todo_service_impl.go - サービスの具体的な実装
3. internal/service/todo_service_test.go - サービス層のテスト

順番に実装していきましょう。

まず、サービスのインターフェースを定義します。

// TodoService はTODOアイテムのサービスのインターフェースです
package service

import (
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
)

// TodoService はTODOアイテムのサービスのインターフェースです
type TodoService interface {
	// GetByID は指定されたIDのTODOアイテムを取得します
	GetByID(id int) (*domain.Todo, error)

	// Create は新しいTODOアイテムを作成します
	Create(title string, dueDate string) (*domain.Todo, error)
}

Made changes.

次に、TodoServiceの実装を行います。todo_service_impl.goファイルを作成します。

package service

import (
	"errors"
	"time"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/repository"
)

var (
	// ErrInvalidDueDate は日付形式が不正な場合のエラーです
	ErrInvalidDueDate = errors.New("invalid due date format")
	// ErrEmptyTitle はタイトルが空の場合のエラーです
	ErrEmptyTitle = errors.New("title cannot be empty")
)

// TodoServiceImpl はTodoServiceインターフェースの実装です
type TodoServiceImpl struct {
	todoRepo repository.TodoRepository
}

// NewTodoService は新しいTodoServiceImplのインスタンスを生成します
func NewTodoService(todoRepo repository.TodoRepository) TodoService {
	return &TodoServiceImpl{
		todoRepo: todoRepo,
	}
}

// GetByID は指定されたIDのTODOアイテムを取得します
func (s *TodoServiceImpl) GetByID(id int) (*domain.Todo, error) {
	return s.todoRepo.GetByID(id)
}

// Create は新しいTODOアイテムを作成します
func (s *TodoServiceImpl) Create(title string, dueDate string) (*domain.Todo, error) {
	// バリデーション
	if title == "" {
		return nil, ErrEmptyTitle
	}

	// 日付文字列をtime.Time型に変換
	parsedDueDate, err := time.Parse(time.RFC3339, dueDate)
	if err != nil {
		return nil, ErrInvalidDueDate
	}

	// TODOアイテムを作成
	todo := &domain.Todo{
		Title:   title,
		DueDate: parsedDueDate,
	}

	// リポジトリに保存
	return s.todoRepo.Create(todo)
}

Made changes.

次に、サービス層のテストを実装します。サービスの機能が正しく動作するかを確認するテストを作成します。

package service

import (
	"errors"
	"testing"
	"time"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/repository"
)

// MockTodoRepository はテスト用のモックリポジトリです
type MockTodoRepository struct {
	todos map[int]*domain.Todo
	nextID int
}

// GetByIDメソッドの実装
func (m *MockTodoRepository) GetByID(id int) (*domain.Todo, error) {
	todo, exists := m.todos[id]
	if !exists {
		return nil, errors.New("todo not found")
	}
	return todo, nil
}

// Createメソッドの実装
func (m *MockTodoRepository) Create(todo *domain.Todo) (*domain.Todo, error) {
	todo.ID = m.nextID
	m.nextID++
	m.todos[todo.ID] = todo
	return todo, nil
}

// NewMockTodoRepository はモックリポジトリのインスタンスを生成します
func NewMockTodoRepository() repository.TodoRepository {
	return &MockTodoRepository{
		todos: make(map[int]*domain.Todo),
		nextID: 1,
	}
}

func TestGetByID(t *testing.T) {
	// モックリポジトリの準備
	repo := NewMockTodoRepository()
	service := NewTodoService(repo)
	
	// テスト用のデータを追加
	dueDate := time.Now().Add(24 * time.Hour)
	todo := &domain.Todo{
		Title:   "テスト用TODO",
		DueDate: dueDate,
	}
	createdTodo, _ := repo.Create(todo)
	
	// テスト実行
	result, err := service.GetByID(createdTodo.ID)
	
	// アサーション
	if err != nil {
		t.Errorf("GetByID failed: %v", err)
	}
	if result == nil {
		t.Error("Expected todo but got nil")
	}
	if result.ID != createdTodo.ID {
		t.Errorf("Expected ID %d but got %d", createdTodo.ID, result.ID)
	}
	if result.Title != "テスト用TODO" {
		t.Errorf("Expected title 'テスト用TODO' but got '%s'", result.Title)
	}
}

func TestGetByIDNotFound(t *testing.T) {
	// モックリポジトリの準備
	repo := NewMockTodoRepository()
	service := NewTodoService(repo)
	
	// 存在しないIDで検索
	_, err := service.GetByID(999)
	
	// アサーション
	if err == nil {
		t.Error("Expected error but got nil")
	}
}

func TestCreate(t *testing.T) {
	// モックリポジトリの準備
	repo := NewMockTodoRepository()
	service := NewTodoService(repo)
	
	// テスト実行
	dueDate := time.Now().Add(24 * time.Hour).Format(time.RFC3339)
	createdTodo, err := service.Create("新しいTODO", dueDate)
	
	// アサーション
	if err != nil {
		t.Errorf("Create failed: %v", err)
	}
	if createdTodo == nil {
		t.Error("Expected todo but got nil")
	}
	if createdTodo.ID <= 0 {
		t.Errorf("Expected positive ID but got %d", createdTodo.ID)
	}
	if createdTodo.Title != "新しいTODO" {
		t.Errorf("Expected title '新しいTODO' but got '%s'", createdTodo.Title)
	}
}

func TestCreateWithEmptyTitle(t *testing.T) {
	// モックリポジトリの準備
	repo := NewMockTodoRepository()
	service := NewTodoService(repo)
	
	// 空のタイトルでテスト実行
	dueDate := time.Now().Add(24 * time.Hour).Format(time.RFC3339)
	_, err := service.Create("", dueDate)
	
	// アサーション
	if err == nil {
		t.Error("Expected error but got nil")
	}
	if !errors.Is(err, ErrEmptyTitle) {
		t.Errorf("Expected ErrEmptyTitle but got %v", err)
	}
}

func TestCreateWithInvalidDueDate(t *testing.T) {
	// モックリポジトリの準備
	repo := NewMockTodoRepository()
	service := NewTodoService(repo)
	
	// 不正な日付形式でテスト実行
	_, err := service.Create("テストTODO", "不正な日付形式")
	
	// アサーション
	if err == nil {
		t.Error("Expected error but got nil")
	}
	if !errors.Is(err, ErrInvalidDueDate) {
		t.Errorf("Expected ErrInvalidDueDate but got %v", err)
	}
}

Made changes.

サービス層の実装が完了しました。これで、TODOアイテムの操作を行うための以下のコンポーネントが実装されました：

1. todo_service.go - TODOサービスのインターフェースを定義
2. todo_service_impl.go - TODOサービスの具体的な実装
3. todo_service_test.go - サービス層のテスト

実装したサービス層では以下の機能を提供しています：

• GetByID: 指定されたIDのTODOアイテムをリポジトリから取得する機能
• Create: タイトルと期限日を受け取り、新しいTODOアイテムを作成してリポジトリに保存する機能

また、テストでは以下のシナリオを検証しています：

• 正常にTODOアイテムが取得できるケース
• 存在しないIDでTODOアイテムを取得しようとした場合のエラーハンドリング
• 正常にTODOアイテムが作成できるケース
• 空のタイトルでTODOアイテムを作成しようとした場合のエラーハンドリング
• 不正な日付形式でTODOアイテムを作成しようとした場合のエラーハンドリング

テストを実行して、実装したサービス層の機能が正しく動作するか確認してみましょう：テストが正常に実行され、すべてのテストケースがパスしました！

サービス層の実装が正しく動作していることが確認できました。サービス層では主に以下の機能を提供しています：

1. GetByID: 指定されたIDのTODOアイテムをリポジトリから取得する機能
2. Create: タイトルと期限日を受け取り、新しいTODOアイテムを作成してリポジトリに保存する機能

また、バリデーション処理として：

• タイトルが空の場合はエラーを返す
• 期限日の形式が不正な場合はエラーを返す

これらの実装により、サービス層はビジネスロジックとデータの整合性を保つ役割を担っています。リクエストデータのバリデーションからリポジトリへの保存処理までを一貫して扱うことができます。

今回実装したサービス層のコードは、次のステップである「4. ハンドラー層の実装」で活用されることになります。HTTPリクエストを受け取るハンドラーがこのサービス層を呼び出すことで、TODOリストAPIの機能が完成します。

#2のissueの「3. サービス層の実装」のタスクが完了しました。次は「4. ハンドラー層の実装」に進むことができます。

4. ハンドラー層の実装

Nao-Mk2: #2のissueの「4. ハンドラー層の実装」を実行して。

---

GitHub Copilot: 「#2のissue」について調査し、「4. ハンドラー層の実装」タスクを実行します。まずはissueの内容を確認しましょう。issue #2の内容を確認しました。このissueでは「TODOリストAPIの実装タスク分解」という題名で、TODOリストを管理するWeb APIサーバーの実装タスクが記載されています。今回は「4. ハンドラー層の実装」を行います。

現在のプロジェクト状況を確認するため、既存のコードを調査しましょう。まずドメインモデル、リポジトリ、サービス層の実装を確認します。Todo ドメインモデルを確認しました。続いてリポジトリとサービス層の実装を確認します。リポジトリインターフェースを確認しました。次にリポジトリの実装とサービス層を見ていきましょう。メモリリポジトリの実装を確認しました。続いてサービス層を見ていきましょう。サービスインターフェースを確認しました。続いて、サービスの実装を確認します。サービス層の実装も確認できました。次にハンドラー層の実装を進めるために、必要なファイルを作成します。まず、handler ディレクトリに todo_handler.go ファイルを作成しましょう。

このファイルでは、HTTPリクエストを処理するハンドラーの実装を行います。Goの標準ライブラリである net/http を使用して実装します。

package handler

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
	"strings"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/service"
)

// TodoHandler はTODOアイテムのHTTPハンドラーです
type TodoHandler struct {
	todoService service.TodoService
}

// NewTodoHandler は新しいTodoHandlerのインスタンスを生成します
func NewTodoHandler(todoService service.TodoService) *TodoHandler {
	return &TodoHandler{
		todoService: todoService,
	}
}

// CreateTodoRequest はTODOアイテム作成リクエストのJSONを表す構造体です
type CreateTodoRequest struct {
	Title   string `json:"title"`
	DueDate string `json:"due_date"`
}

// ServeHTTP はHTTPリクエストを処理するハンドラー関数です
func (h *TodoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// URLパスからIDを抽出するための処理
	path := strings.TrimPrefix(r.URL.Path, "/todo")

	// Content-TypeをJSONに設定
	w.Header().Set("Content-Type", "application/json")

	if path == "" || path == "/" {
		// /todoへのリクエスト
		switch r.Method {
		case http.MethodPost:
			h.createTodo(w, r)
		default:
			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		}
		return
	}

	// /todo/{id}へのリクエスト
	id, err := strconv.Atoi(strings.TrimPrefix(path, "/"))
	if err != nil {
		http.Error(w, "Invalid todo ID", http.StatusBadRequest)
		return
	}

	switch r.Method {
	case http.MethodGet:
		h.getTodo(w, r, id)
	default:
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
	}
}

// createTodo はTODOアイテムを作成するハンドラー関数です
func (h *TodoHandler) createTodo(w http.ResponseWriter, r *http.Request) {
	var req CreateTodoRequest
	decoder := json.NewDecoder(r.Body)
	if err := decoder.Decode(&req); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		json.NewEncoder(w).Encode(map[string]string{"error": "Invalid request body"})
		return
	}

	todo, err := h.todoService.Create(req.Title, req.DueDate)
	if err != nil {
		// エラーによって適切なHTTPステータスを返す
		switch err {
		case service.ErrEmptyTitle:
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(map[string]string{"error": "Title cannot be empty"})
		case service.ErrInvalidDueDate:
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(map[string]string{"error": "Invalid due date format"})
		default:
			w.WriteHeader(http.StatusInternalServerError)
			json.NewEncoder(w).Encode(map[string]string{"error": "Internal server error"})
		}
		return
	}

	// 成功レスポンス
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(todo)
}

// getTodo は指定されたIDのTODOアイテムを取得するハンドラー関数です
func (h *TodoHandler) getTodo(w http.ResponseWriter, r *http.Request, id int) {
	todo, err := h.todoService.GetByID(id)
	if err != nil {
		// エラーによって適切なHTTPステータスを返す
		w.WriteHeader(http.StatusNotFound)
		json.NewEncoder(w).Encode(map[string]string{"error": fmt.Sprintf("Todo with ID %d not found", id)})
		return
	}

	// 成功レスポンス
	json.NewEncoder(w).Encode(todo)
}

Made changes.

次に、ハンドラーのテストを実装します。テストではHTTPリクエストをモックして、正しいレスポンスが返されるかを検証します。

package handler

import (
	"bytes"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/service"
)

// MockTodoService はテスト用のモックサービスです
type MockTodoService struct {
	GetByIDFunc func(id int) (*domain.Todo, error)
	CreateFunc  func(title string, dueDate string) (*domain.Todo, error)
}

func (m *MockTodoService) GetByID(id int) (*domain.Todo, error) {
	return m.GetByIDFunc(id)
}

func (m *MockTodoService) Create(title string, dueDate string) (*domain.Todo, error) {
	return m.CreateFunc(title, dueDate)
}

func TestGetTodo(t *testing.T) {
	// テスト用の日付
	dueDate := time.Date(2025, 12, 31, 23, 59, 59, 0, time.UTC)

	// テストケース
	testCases := []struct {
		name           string
		todoID         string
		mockGetByIDFunc func(id int) (*domain.Todo, error)
		expectedStatus  int
		expectedBody    string
	}{
		{
			name:   "正常系 - TODOアイテムの取得",
			todoID: "1",
			mockGetByIDFunc: func(id int) (*domain.Todo, error) {
				return &domain.Todo{
					ID:      1,
					Title:   "テストTODO",
					DueDate: dueDate,
				}, nil
			},
			expectedStatus: http.StatusOK,
			// 期待されるJSONにはdueDate形式が反映されることに注意
			expectedBody: `{"id":1,"title":"テストTODO","due_date":"2025-12-31T23:59:59Z"}`,
		},
		{
			name:   "異常系 - TODOアイテムが存在しない",
			todoID: "999",
			mockGetByIDFunc: func(id int) (*domain.Todo, error) {
				return nil, errors.New("todo not found")
			},
			expectedStatus: http.StatusNotFound,
			expectedBody:   `{"error":"Todo with ID 999 not found"}`,
		},
		{
			name:           "異常系 - 不正なID",
			todoID:         "invalid",
			mockGetByIDFunc: nil, // この場合は呼ばれない
			expectedStatus:  http.StatusBadRequest,
			expectedBody:    `Invalid todo ID`,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// モックサービスの準備
			mockService := &MockTodoService{
				GetByIDFunc: tc.mockGetByIDFunc,
			}

			// ハンドラーの生成
			handler := NewTodoHandler(mockService)

			// リクエストの作成
			req, err := http.NewRequest(http.MethodGet, "/todo/"+tc.todoID, nil)
			if err != nil {
				t.Fatal(err)
			}

			// レスポンスレコーダーの作成
			rr := httptest.NewRecorder()

			// リクエストの実行
			handler.ServeHTTP(rr, req)

			// ステータスコードの検証
			if status := rr.Code; status != tc.expectedStatus {
				t.Errorf("期待したステータスコード %v が %v と一致しません", tc.expectedStatus, status)
			}

			// レスポンスボディの検証（BadRequestの場合は部分一致チェック）
			if tc.expectedStatus == http.StatusBadRequest && tc.todoID == "invalid" {
				if rr.Body.String() != "Invalid todo ID\n" {
					t.Errorf("期待したレスポンスボディ %q が %q と一致しません", "Invalid todo ID", rr.Body.String())
				}
			} else {
				// JSONレスポンスの場合は改行を削除して比較
				actual := rr.Body.String()
				actual = actual[:len(actual)-1] // 末尾の改行を削除
				if actual != tc.expectedBody {
					t.Errorf("期待したレスポンスボディ %q が %q と一致しません", tc.expectedBody, actual)
				}
			}
		})
	}
}

func TestCreateTodo(t *testing.T) {
	// テスト用の日付
	dueDate := "2025-12-31T23:59:59Z"
	parsedDueDate, _ := time.Parse(time.RFC3339, dueDate)

	// テストケース
	testCases := []struct {
		name            string
		requestBody     string
		mockCreateFunc  func(title string, dueDate string) (*domain.Todo, error)
		expectedStatus  int
		expectedBody    string
	}{
		{
			name:        "正常系 - TODOアイテムの作成",
			requestBody: `{"title":"新しいTODO","due_date":"2025-12-31T23:59:59Z"}`,
			mockCreateFunc: func(title string, dueDate string) (*domain.Todo, error) {
				return &domain.Todo{
					ID:      1,
					Title:   title,
					DueDate: parsedDueDate,
				}, nil
			},
			expectedStatus: http.StatusCreated,
			expectedBody:   `{"id":1,"title":"新しいTODO","due_date":"2025-12-31T23:59:59Z"}`,
		},
		{
			name:        "異常系 - タイトルが空",
			requestBody: `{"title":"","due_date":"2025-12-31T23:59:59Z"}`,
			mockCreateFunc: func(title string, dueDate string) (*domain.Todo, error) {
				return nil, service.ErrEmptyTitle
			},
			expectedStatus: http.StatusBadRequest,
			expectedBody:   `{"error":"Title cannot be empty"}`,
		},
		{
			name:        "異常系 - 不正な日付形式",
			requestBody: `{"title":"新しいTODO","due_date":"不正な日付"}`,
			mockCreateFunc: func(title string, dueDate string) (*domain.Todo, error) {
				return nil, service.ErrInvalidDueDate
			},
			expectedStatus: http.StatusBadRequest,
			expectedBody:   `{"error":"Invalid due date format"}`,
		},
		{
			name:        "異常系 - 不正なリクエストボディ",
			requestBody: `不正なJSON`,
			mockCreateFunc: func(title string, dueDate string) (*domain.Todo, error) {
				return nil, nil // この場合は呼ばれない
			},
			expectedStatus: http.StatusBadRequest,
			expectedBody:   `{"error":"Invalid request body"}`,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// モックサービスの準備
			mockService := &MockTodoService{
				CreateFunc: tc.mockCreateFunc,
			}

			// ハンドラーの生成
			handler := NewTodoHandler(mockService)

			// リクエストの作成
			req, err := http.NewRequest(http.MethodPost, "/todo", bytes.NewBufferString(tc.requestBody))
			if err != nil {
				t.Fatal(err)
			}
			req.Header.Set("Content-Type", "application/json")

			// レスポンスレコーダーの作成
			rr := httptest.NewRecorder()

			// リクエストの実行
			handler.ServeHTTP(rr, req)

			// ステータスコードの検証
			if status := rr.Code; status != tc.expectedStatus {
				t.Errorf("期待したステータスコード %v が %v と一致しません", tc.expectedStatus, status)
			}

			// レスポンスボディの検証
			actual := rr.Body.String()
			actual = actual[:len(actual)-1] // 末尾の改行を削除
			if actual != tc.expectedBody {
				t.Errorf("期待したレスポンスボディ %q が %q と一致しません", tc.expectedBody, actual)
			}
		})
	}
}

func TestMethodNotAllowed(t *testing.T) {
	// テストケース
	testCases := []struct {
		name           string
		method         string
		path           string
		expectedStatus int
	}{
		{
			name:           "異常系 - /todoにGETリクエスト",
			method:         http.MethodGet,
			path:           "/todo",
			expectedStatus: http.StatusMethodNotAllowed,
		},
		{
			name:           "異常系 - /todo/1にPOSTリクエスト",
			method:         http.MethodPost,
			path:           "/todo/1",
			expectedStatus: http.StatusMethodNotAllowed,
		},
		{
			name:           "異常系 - /todoにPUTリクエスト",
			method:         http.MethodPut,
			path:           "/todo",
			expectedStatus: http.StatusMethodNotAllowed,
		},
		{
			name:           "異常系 - /todo/1にDELETEリクエスト",
			method:         http.MethodDelete,
			path:           "/todo/1",
			expectedStatus: http.StatusMethodNotAllowed,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// モックサービスの準備
			mockService := &MockTodoService{}

			// ハンドラーの生成
			handler := NewTodoHandler(mockService)

			// リクエストの作成
			req, err := http.NewRequest(tc.method, tc.path, nil)
			if err != nil {
				t.Fatal(err)
			}

			// レスポンスレコーダーの作成
			rr := httptest.NewRecorder()

			// リクエストの実行
			handler.ServeHTTP(rr, req)

			// ステータスコードの検証
			if status := rr.Code; status != tc.expectedStatus {
				t.Errorf("期待したステータスコード %v が %v と一致しません", tc.expectedStatus, status)
			}
		})
	}
}

Made changes.

作成したコードを確認しましょう。エラーがないか確認します。テストコードに小さなエラーがあります。encoding/json パッケージがインポートされていますが使用されていないようです。この問題を修正しましょう。

package handler

import (
	"bytes"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/domain"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/service"
)

// ...existing code...

Made changes.

修正後のコードにエラーがないか再確認しましょう。エラーが修正され、ハンドラー層の実装が完了しました。

実装したコードの概要を説明します：

1. TodoHandler の実装 (todo_handler.go):

   • TodoHandler 構造体と NewTodoHandler コンストラクタを定義しました
   • ServeHTTP メソッドでHTTPリクエストのルーティング処理を実装しました
   • /todo へのPOSTリクエストで新しいTODOを作成する createTodo メソッド
   • /todo/{id} へのGETリクエストで特定のTODOを取得する getTodo メソッド
   • 各種エラーに対する適切なHTTPステータスコードとJSONレスポンスの返却処理

2. TodoHandler のテスト (todo_handler_test.go):

   • モックサービスを使用してハンドラーの動作をテスト
   • 正常系と各種異常系（存在しないID、不正なID、空のタイトル、不正な日付形式など）のテストケース
   • 許可されていないHTTPメソッドに対するテスト

これで「4. ハンドラー層の実装」のタスクは完了しました。ハンドラーは適切にTODOアイテムの作成と取得のためのエンドポイントを提供し、テストコードによってその動作が検証されています。

次のステップとしては、「5. メインアプリケーションの実装」に進むことができます。メインアプリケーションでは、今回実装したハンドラーを使用してHTTPサーバーを設定し、起動する処理を実装することになります。

5. メインアプリケーションの実装

Nao-Mk2: #2のissueの「5. メインアプリケーションの実装」を実行して。

---

GitHub Copilot: GitHub Copilotとして、#2のissueの「5. メインアプリケーションの実装」について実行します。まず、このissueの詳細内容を確認しましょう。issueの内容を確認しました。「5. メインアプリケーションの実装」のタスクでは、HTTPサーバーの設定と起動、ルーティングの設定を行う必要があります。

まず、現在のコードベースを確認して、必要なファイルとその実装状況を把握しましょう。

メインアプリケーションは cmd/server/main.go に実装する必要があります。このファイルが存在するか確認します。cmd/server/main.goが存在しないようです。タスク「5. メインアプリケーションの実装」を実行するために、このファイルを作成する必要があります。

既存の実装を確認するため、各レイヤーの実装状況をチェックしましょう。まず、リポジトリ、サービス、ハンドラー層の実装を確認します。ドメインモデルを確認しました。Todo構造体が定義されており、IDとタイトル、期限のフィールドがJSON形式で出力できるよう設定されています。

次に、リポジトリの実装を確認しましょう。リポジトリのインターフェースを確認しました。TodoRepositoryインターフェースにはGetByIDメソッドとCreateメソッドが定義されています。

次に、メモリリポジトリの実装を確認します。メモリリポジトリの実装を確認しました。MemoryTodoRepository構造体が実装されており、GetByIDとCreateメソッドが提供されています。

次に、サービス層の実装を確認しましょう。サービス層のインターフェースを確認しました。TodoServiceインターフェースにはGetByIDとCreateメソッドが定義されています。続いてサービス実装も確認しましょう。サービス層の実装も確認できました。TodoServiceImpl構造体が実装されており、GetByIDとCreateメソッドが提供されています。

最後に、ハンドラー層の実装を確認しましょう。ハンドラー層の実装も確認できました。TodoHandler構造体が実装されており、HTTP リクエストを処理するためのハンドラー関数が提供されています。

これで、ドメインモデル、リポジトリ層、サービス層、ハンドラー層の実装が揃っていることが分かりました。次に、タスク「5. メインアプリケーションの実装」に対応するために、cmd/server/main.goを作成する必要があります。

まず、serverディレクトリが存在するか確認しましょう。serverディレクトリは存在していますね。では、メインアプリケーションファイルを作成していきましょう。

これからcmd/server/main.goファイルを作成し、TODOリストAPIサーバーのエントリーポイントを実装します。このファイルでは、以下の処理を行います：

1. HTTPサーバーの設定と起動
2. 必要な依存関係の初期化（リポジトリ、サービス、ハンドラー）
3. ルーティングの設定

それでは、main.goファイルを作成しましょう：

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"

	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/handler"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/repository/memory"
	"github.com/Nao-Mk2/nao_github_copilot_lab/internal/service"
)

const (
	// サーバーのデフォルトポート
	defaultPort = "8080"
)

func main() {
	// ポート設定
	port := os.Getenv("PORT")
	if port == "" {
		port = defaultPort
	}

	// 依存関係の初期化
	// リポジトリ層
	todoRepo := memory.NewMemoryTodoRepository()

	// サービス層
	todoService := service.NewTodoService(todoRepo)

	// ハンドラー層
	todoHandler := handler.NewTodoHandler(todoService)

	// ルーティング設定
	mux := http.NewServeMux()
	mux.Handle("/todo", todoHandler)
	mux.Handle("/todo/", todoHandler)

	// HTTPサーバーの設定
	server := &http.Server{
		Addr:    ":" + port,
		Handler: mux,
	}

	// サーバー起動を別のゴルーチンで実行
	go func() {
		fmt.Printf("サーバーを開始します (ポート: %s)\n", port)
		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("サーバー起動エラー: %v", err)
		}
	}()

	// シグナル処理（Ctrl+C などで適切に終了させるため）
	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)

	// シグナルを待つ
	<-stop
	fmt.Println("サーバーを停止しています...")
}

Made changes.

ファイルを作成しました。cmd/server/main.goには以下の機能を実装しました：

1. HTTPサーバーの設定と起動

   • デフォルトのポート8080で起動します（環境変数PORTで変更可能）
   • 優雅に終了できるようにシグナル処理を追加しました

2. 依存関係の初期化

   • メモリ上のTODOリポジトリを初期化
   • TODOサービスの初期化
   • TODOハンドラーの初期化

3. ルーティングの設定

   • /todoと/todo/パスのリクエストをTODOハンドラーにルーティング
   • ハンドラー内で適切なHTTPメソッド（GETやPOST）と子パス（/todo/1など）に応じて処理を分岐

これで、タスク「5. メインアプリケーションの実装」が完了しました。

サーバーを起動するには、プロジェクトのルートディレクトリで以下のコマンドを実行します：

go run cmd/server/main.go

実行すると、サーバーがポート8080で起動し、以下のAPIエンドポイントが利用可能になります：

• GET /todo/{id}: 指定したIDのTODOアイテムを取得
• POST /todo: 新しいTODOアイテムを作成（JSONリクエストボディが必要）

POSTリクエストのサンプル：

{
  "title": "Goの勉強をする",
  "due_date": "2025-04-30T23:59:59Z"
}

これで、issue #2の「5. メインアプリケーションの実装」のタスクが完了しました。次のステップは「6. 動作確認」です。サーバーを起動して実際にAPIが意図通りに動作するか確認されると良いでしょう。

[Nao-Mk2]

実装したブランチ: https://github.com/Nao-Mk2/nao_github_copilot_lab/tree/todo_api

こんな形で最低限は動く

$ curl localhost:8080/todo/1
{"error":"Todo with ID 1 not found"}

$ curl -X POST localhost:8080/todo -d '{"id": 1, "title": "todoサンプル", "due_date": "2026-01-01T00:00:00+09:00"}'
{"id":1,"title":"todoサンプル","due_date":"2026-01-01T00:00:00+09:00"}

$ curl localhost:8080/todo/1
{"id":1,"title":"todoサンプル","due_date":"2026-01-01T00:00:00+09:00"}