feat(image): add task endpoints

Author: JSYoo5B

internal/api/image/router.go

@@ -34,6 +34,7 @@ func NewHandler(cfg config.Config) Handler {
 			storeimage.NewMemoryRepository(),
 			storeimage.NewMemoryDataRepository(),
 			storeimage.NewMemoryMemberRepository(),
+			storeimage.NewMemoryTaskRepository(),
 			clock.Wall(),
 			idgen.Random(),
 		),
@@ -63,6 +64,9 @@ func (h Handler) Router() http.Handler {
 	router.Put("/images/{image_id}/stage", h.stageImageData)
 	router.Post("/images/{image_id}/import", h.importImageData)
 	router.Get("/info/import", h.getImportInfo)
+	router.Get("/tasks", h.listTasks)
+	router.Post("/tasks", h.createTask)
+	router.Get("/tasks/{task_id}", h.getTask)
 	router.Get("/images/{image_id}/members", h.listMembers)
 	router.Post("/images/{image_id}/members", h.createMember)
 	router.Get("/images/{image_id}/members/{member_id}", h.getMember)

internal/api/image/task.go

@@ -0,0 +1,44 @@
+package image
+
+import (
+	"encoding/json"
+	"errors"
+	"net/http"
+
+	"github.com/JSYoo5B/SandStack/internal/api/respond"
+	appimage "github.com/JSYoo5B/SandStack/internal/app/image"
+	"github.com/go-chi/chi/v5"
+)
+
+func (h Handler) listTasks(w http.ResponseWriter, r *http.Request) {
+	respond.JSON(w, http.StatusOK, taskListResponse{
+		Tasks: toTaskDocuments(h.service.ListTasks()),
+		Next:  "",
+	})
+}
+
+func (h Handler) createTask(w http.ResponseWriter, r *http.Request) {
+	var request createTaskRequest
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		respond.Error(w, http.StatusBadRequest, "invalid JSON request body")
+		return
+	}
+
+	task := h.service.CreateTask(request.createTask())
+
+	respond.JSON(w, http.StatusCreated, toTaskDocument(task))
+}
+
+func (h Handler) getTask(w http.ResponseWriter, r *http.Request) {
+	task, err := h.service.GetTask(chi.URLParam(r, "task_id"))
+	if errors.Is(err, appimage.ErrTaskNotFound) {
+		respond.Error(w, http.StatusNotFound, "task not found")
+		return
+	}
+	if err != nil {
+		respond.Error(w, http.StatusInternalServerError, "task lookup failed")
+		return
+	}
+
+	respond.JSON(w, http.StatusOK, toTaskDocument(task))
+}

internal/api/image/task_dto.go

@@ -0,0 +1,61 @@
+package image
+
+import appimage "github.com/JSYoo5B/SandStack/internal/app/image"
+
+type createTaskRequest struct {
+	Type  string         `json:"type"`
+	Input map[string]any `json:"input"`
+}
+
+type taskListResponse struct {
+	Tasks []taskDocument `json:"tasks"`
+	Next  string         `json:"next"`
+}
+
+type taskDocument struct {
+	ID        string         `json:"id"`
+	Type      string         `json:"type"`
+	Status    string         `json:"status"`
+	Input     map[string]any `json:"input"`
+	Result    map[string]any `json:"result"`
+	Owner     string         `json:"owner"`
+	Message   string         `json:"message"`
+	ExpiresAt string         `json:"expires_at"`
+	CreatedAt string         `json:"created_at"`
+	UpdatedAt string         `json:"updated_at"`
+	Self      string         `json:"self"`
+	Schema    string         `json:"schema"`
+}
+
+func (r createTaskRequest) createTask() appimage.CreateTask {
+	return appimage.CreateTask{
+		Type:  r.Type,
+		Input: r.Input,
+	}
+}
+
+func toTaskDocuments(tasks []appimage.Task) []taskDocument {
+	documents := make([]taskDocument, 0, len(tasks))
+	for _, task := range tasks {
+		documents = append(documents, toTaskDocument(task))
+	}
+
+	return documents
+}
+
+func toTaskDocument(task appimage.Task) taskDocument {
+	return taskDocument{
+		ID:        task.ID,
+		Type:      task.Type,
+		Status:    task.Status,
+		Input:     task.Input,
+		Result:    task.Result,
+		Owner:     task.Owner,
+		Message:   task.Message,
+		ExpiresAt: task.ExpiresAt,
+		CreatedAt: task.CreatedAt,
+		UpdatedAt: task.UpdatedAt,
+		Self:      "/v2/tasks/" + task.ID,
+		Schema:    "/v2/schemas/task",
+	}
+}

internal/api/image/task_test.go

@@ -0,0 +1,61 @@
+package image_test
+
+import (
+	"context"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/JSYoo5B/SandStack/internal/api/image"
+	"github.com/JSYoo5B/SandStack/internal/testhelper"
+	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/tasks"
+	"github.com/stretchr/testify/suite"
+)
+
+type TaskSuite struct {
+	suite.Suite
+	server *httptest.Server
+}
+
+func TestTaskSuite(t *testing.T) {
+	suite.Run(t, new(TaskSuite))
+}
+
+func (s *TaskSuite) SetupTest() {
+	s.server = httptest.NewServer(
+		image.NewRouter(testhelper.DefaultConfig()),
+	)
+}
+
+func (s *TaskSuite) TearDownTest() {
+	s.server.Close()
+}
+
+func (s *TaskSuite) TestCreateGetAndListTask() {
+	client := testhelper.ServiceClient(s.server.URL)
+
+	created, err := tasks.Create(
+		context.Background(),
+		client,
+		tasks.CreateOpts{
+			Type: "import",
+			Input: map[string]any{
+				"image_id": "image-1",
+			},
+		},
+	).Extract()
+	s.Require().NoError(err)
+
+	found, err := tasks.Get(context.Background(), client, created.ID).Extract()
+	s.Require().NoError(err)
+
+	pages, err := tasks.List(client, nil).AllPages(context.Background())
+	s.Require().NoError(err)
+
+	listed, err := tasks.ExtractTasks(pages)
+	s.Require().NoError(err)
+
+	s.Assert().Equal("import", found.Type)
+	s.Assert().Equal(tasks.TaskStatusPending, tasks.TaskStatus(found.Status))
+	s.Require().Len(listed, 1)
+	s.Assert().Equal(created.ID, listed[0].ID)
+}

internal/api/router.go

@@ -56,6 +56,7 @@ func NewRouter(cfg config.Config) http.Handler {
 		storeimage.NewMemoryRepository(),
 		storeimage.NewMemoryDataRepository(),
 		storeimage.NewMemoryMemberRepository(),
+		storeimage.NewMemoryTaskRepository(),
 		clock.Wall(),
 		idgen.Random(),
 	)

internal/app/image/repository.go

@@ -24,3 +24,10 @@ type MemberRepository interface {
 	Delete(imageID string, memberID string) error
 	Reset()
 }
+
+type TaskRepository interface {
+	Create(task Task) Task
+	List() []Task
+	Get(id string) (Task, error)
+	Reset()
+}

internal/app/image/service.go

@@ -9,11 +9,13 @@ import (
 )
 
 var ErrImageNotFound = errors.New("image not found")
+var ErrTaskNotFound = errors.New("task not found")
 
 type Service struct {
 	repository       Repository
 	dataRepository   DataRepository
 	memberRepository MemberRepository
+	taskRepository   TaskRepository
 	clock            clock.Clock
 	idGen            idgen.Generator
 }
@@ -22,13 +24,15 @@ func NewServiceWithRuntime(
 	repository Repository,
 	dataRepository DataRepository,
 	memberRepository MemberRepository,
+	taskRepository TaskRepository,
 	clock clock.Clock,
 	idGen idgen.Generator,
 ) *Service {
 	return &Service{
 		repository:       repository,
 		dataRepository:   dataRepository,
 		memberRepository: memberRepository,
+		taskRepository:   taskRepository,
 		clock:            clock,
 		idGen:            idGen,
 	}
@@ -74,4 +78,5 @@ func (s *Service) Reset() {
 	s.repository.Reset()
 	s.dataRepository.Reset()
 	s.memberRepository.Reset()
+	s.taskRepository.Reset()
 }

internal/app/image/service_test.go

@@ -25,6 +25,7 @@ func (s *ServiceSuite) TestCreateImageUsesInjectedClock() {
 		storeimage.NewMemoryRepository(),
 		storeimage.NewMemoryDataRepository(),
 		storeimage.NewMemoryMemberRepository(),
+		storeimage.NewMemoryTaskRepository(),
 		clock.Fixed(now),
 		idgen.Random(),
 	)
@@ -44,6 +45,7 @@ func (s *ServiceSuite) TestCreateImageUsesInjectedIDGenerator() {
 		storeimage.NewMemoryRepository(),
 		storeimage.NewMemoryDataRepository(),
 		storeimage.NewMemoryMemberRepository(),
+		storeimage.NewMemoryTaskRepository(),
 		clock.Fixed(time.Time{}),
 		idgen.Fixed("image-id"),
 	)
@@ -62,6 +64,7 @@ func (s *ServiceSuite) TestResetClearsImages() {
 		storeimage.NewMemoryRepository(),
 		storeimage.NewMemoryDataRepository(),
 		storeimage.NewMemoryMemberRepository(),
+		storeimage.NewMemoryTaskRepository(),
 		clock.Fixed(time.Time{}),
 		idgen.Fixed("image-id"),
 	)
@@ -74,6 +77,7 @@ func (s *ServiceSuite) TestResetClearsImages() {
 	s.Require().NoError(err)
 	_, err = service.CreateMember(created.ID, "project-1")
 	s.Require().NoError(err)
+	task := service.CreateTask(image.CreateTask{Type: "import"})
 
 	service.Reset()
 
@@ -83,4 +87,6 @@ func (s *ServiceSuite) TestResetClearsImages() {
 	members, err := service.ListMembers(created.ID)
 	s.ErrorIs(err, image.ErrImageNotFound)
 	s.Nil(members)
+	_, err = service.GetTask(task.ID)
+	s.ErrorIs(err, image.ErrTaskNotFound)
 }

internal/app/image/task.go

@@ -0,0 +1,28 @@
+package image
+
+import "time"
+
+func (s *Service) CreateTask(input CreateTask) Task {
+	now := s.clock.Now().UTC()
+	task := Task{
+		ID:        "task-" + s.idGen.Hex(16),
+		Type:      input.Type,
+		Status:    "pending",
+		Input:     input.Input,
+		Result:    map[string]any{},
+		Owner:     "admin",
+		ExpiresAt: now.Add(24 * time.Hour).Format(time.RFC3339),
+		CreatedAt: now.Format(time.RFC3339),
+		UpdatedAt: now.Format(time.RFC3339),
+	}
+
+	return s.taskRepository.Create(task)
+}
+
+func (s *Service) ListTasks() []Task {
+	return s.taskRepository.List()
+}
+
+func (s *Service) GetTask(id string) (Task, error) {
+	return s.taskRepository.Get(id)
+}

internal/app/image/types.go

@@ -32,3 +32,21 @@ type Member struct {
 	CreatedAt string
 	UpdatedAt string
 }
+
+type Task struct {
+	ID        string
+	Type      string
+	Status    string
+	Input     map[string]any
+	Result    map[string]any
+	Owner     string
+	Message   string
+	ExpiresAt string
+	CreatedAt string
+	UpdatedAt string
+}
+
+type CreateTask struct {
+	Type  string
+	Input map[string]any
+}