nex/backend/internal/service/service_supplemental_test.go

package service

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"nex/backend/internal/domain"
	"nex/backend/internal/repository"
)

func TestProviderService_Update(t *testing.T) {
	db := setupServiceTestDB(t)
	repo := repository.NewProviderRepository(db)
	svc := NewProviderService(repo)

	svc.Create(&domain.Provider{ID: "p1", Name: "Original", APIKey: "key", BaseURL: "https://test.com"})

	err := svc.Update("p1", map[string]interface{}{"name": "Updated"})
	require.NoError(t, err)

	result, err := svc.Get("p1", false)
	require.NoError(t, err)
	assert.Equal(t, "Updated", result.Name)
}

func TestProviderService_Update_NotFound(t *testing.T) {
	db := setupServiceTestDB(t)
	repo := repository.NewProviderRepository(db)
	svc := NewProviderService(repo)

	err := svc.Update("nonexistent", map[string]interface{}{"name": "test"})
	assert.Error(t, err)
}

func TestModelService_Get(t *testing.T) {
	db := setupServiceTestDB(t)
	providerRepo := repository.NewProviderRepository(db)
	modelRepo := repository.NewModelRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	providerRepo.Create(&domain.Provider{ID: "p1", Name: "P1", APIKey: "key", BaseURL: "https://test.com"})
	svc.Create(&domain.Model{ID: "m1", ProviderID: "p1", ModelName: "gpt-4"})

	model, err := svc.Get("m1")
	require.NoError(t, err)
	assert.Equal(t, "gpt-4", model.ModelName)
}

func TestModelService_Update(t *testing.T) {
	db := setupServiceTestDB(t)
	providerRepo := repository.NewProviderRepository(db)
	modelRepo := repository.NewModelRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	providerRepo.Create(&domain.Provider{ID: "p1", Name: "P1", APIKey: "key", BaseURL: "https://test.com"})
	svc.Create(&domain.Model{ID: "m1", ProviderID: "p1", ModelName: "gpt-4"})

	err := svc.Update("m1", map[string]interface{}{"model_name": "gpt-4o"})
	require.NoError(t, err)

	model, err := svc.Get("m1")
	require.NoError(t, err)
	assert.Equal(t, "gpt-4o", model.ModelName)
}

func TestModelService_Update_ProviderID_Invalid(t *testing.T) {
	db := setupServiceTestDB(t)
	providerRepo := repository.NewProviderRepository(db)
	modelRepo := repository.NewModelRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	providerRepo.Create(&domain.Provider{ID: "p1", Name: "P1", APIKey: "key", BaseURL: "https://test.com"})
	svc.Create(&domain.Model{ID: "m1", ProviderID: "p1", ModelName: "gpt-4"})

	err := svc.Update("m1", map[string]interface{}{"provider_id": "nonexistent"})
	assert.Error(t, err)
}

func TestModelService_Delete(t *testing.T) {
	db := setupServiceTestDB(t)
	providerRepo := repository.NewProviderRepository(db)
	modelRepo := repository.NewModelRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	providerRepo.Create(&domain.Provider{ID: "p1", Name: "P1", APIKey: "key", BaseURL: "https://test.com"})
	svc.Create(&domain.Model{ID: "m1", ProviderID: "p1", ModelName: "gpt-4"})

	err := svc.Delete("m1")
	require.NoError(t, err)

	_, err = svc.Get("m1")
	assert.Error(t, err)
}

func TestModelService_Delete_NotFound(t *testing.T) {
	db := setupServiceTestDB(t)
	modelRepo := repository.NewModelRepository(db)
	providerRepo := repository.NewProviderRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	err := svc.Delete("nonexistent")
	assert.Error(t, err)
}

func TestStatsService_Aggregate_ByModel(t *testing.T) {
	statsRepo := repository.NewStatsRepository(nil)
	svc := NewStatsService(statsRepo)

	stats := []domain.UsageStats{
		{ProviderID: "p1", ModelName: "gpt-4", RequestCount: 10},
		{ProviderID: "p1", ModelName: "gpt-4", RequestCount: 5},
		{ProviderID: "p2", ModelName: "gpt-4", RequestCount: 8},
	}

	result := svc.Aggregate(stats, "model")
	assert.True(t, len(result) >= 1)

	totalCount := 0
	for _, r := range result {
		totalCount += r["request_count"].(int)
	}
	assert.Equal(t, 23, totalCount)
}

func TestStatsService_Aggregate_Default(t *testing.T) {
	statsRepo := repository.NewStatsRepository(nil)
	svc := NewStatsService(statsRepo)

	stats := []domain.UsageStats{
		{ProviderID: "p1", RequestCount: 10},
		{ProviderID: "p2", RequestCount: 5},
	}

	result := svc.Aggregate(stats, "")
	assert.Len(t, result, 2)

	totalCount := 0
	for _, r := range result {
		totalCount += r["request_count"].(int)
	}
	assert.Equal(t, 15, totalCount)
}

func TestModelService_Update_NotFound(t *testing.T) {
	db := setupServiceTestDB(t)
	modelRepo := repository.NewModelRepository(db)
	providerRepo := repository.NewProviderRepository(db)
	svc := NewModelService(modelRepo, providerRepo)

	err := svc.Update("nonexistent", map[string]interface{}{"model_name": "test"})
	assert.Error(t, err)
}