job-cheng-xing/service/order_test.go

package service

import (
	"testing"
	"time"

	"job-cheng-xing/model"
	"job-cheng-xing/repository"
)

func TestCreateOrder(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	req := model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳区xxx路xxx号",
	}

	order, err := svc.CreateOrder(req)
	if err != nil {
		t.Fatalf("CreateOrder failed: %v", err)
	}
	if order.ID == "" {
		t.Error("expected non-empty ID")
	}
	if order.Status != model.StatusPending {
		t.Errorf("expected pending, got %s", order.Status)
	}
	if order.ProviderID != nil {
		t.Error("expected nil ProviderID")
	}
}

func TestAcceptOrder_Success(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})

	result, err := svc.AcceptOrder(order.ID, "prov_001")
	if err != nil {
		t.Fatalf("AcceptOrder failed: %v", err)
	}
	if result.Status != model.StatusAccepted {
		t.Errorf("expected accepted, got %s", result.Status)
	}
	if *result.ProviderID != "prov_001" {
		t.Errorf("expected prov_001, got %s", *result.ProviderID)
	}
}

func TestAcceptOrder_AlreadyAccepted(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})
	svc.AcceptOrder(order.ID, "prov_001")

	_, err := svc.AcceptOrder(order.ID, "prov_002")
	if err == nil {
		t.Fatal("expected error")
	}
	appErr, ok := err.(*model.AppError)
	if !ok || appErr.Code != "conflict" {
		t.Errorf("expected conflict error, got %v", err)
	}
}

func TestAcceptOrder_OrderNotFound(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	_, err := svc.AcceptOrder("nonexistent", "prov_001")
	if err != model.ErrNotFound {
		t.Errorf("expected ErrNotFound, got %v", err)
	}
}

func TestCancelOrder_FromPending(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})

	result, err := svc.CancelOrder(order.ID)
	if err != nil {
		t.Fatalf("CancelOrder failed: %v", err)
	}
	if result.Status != model.StatusCanceled {
		t.Errorf("expected canceled, got %s", result.Status)
	}
}

func TestCancelOrder_FromAccepted(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})
	svc.AcceptOrder(order.ID, "prov_001")

	result, err := svc.CancelOrder(order.ID)
	if err != nil {
		t.Fatalf("CancelOrder failed: %v", err)
	}
	if result.Status != model.StatusCanceled {
		t.Errorf("expected canceled, got %s", result.Status)
	}
}

func TestCancelOrder_AlreadyCanceled(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})
	svc.CancelOrder(order.ID)

	_, err := svc.CancelOrder(order.ID)
	if err == nil {
		t.Fatal("expected error")
	}
	appErr, ok := err.(*model.AppError)
	if !ok || appErr.Code != "invalid_state" {
		t.Errorf("expected invalid_state error, got %v", err)
	}
}

func TestAcceptOrder_AfterCanceled(t *testing.T) {
	repo := repository.NewMemoryRepo()
	svc := NewOrderService(repo)

	order, _ := svc.CreateOrder(model.CreateOrderRequest{
		ServiceTime: time.Now().Add(24 * time.Hour),
		Duration:    120,
		Address:     "北京朝阳",
	})
	svc.CancelOrder(order.ID)

	_, err := svc.AcceptOrder(order.ID, "prov_001")
	if err == nil {
		t.Fatal("expected error")
	}
	appErr, ok := err.(*model.AppError)
	if !ok || appErr.Code != "invalid_state" {
		t.Errorf("expected invalid_state error, got %v", err)
	}
}