apskel-pos-backend/internal/processor/analytics_processor_test.go

package processor

import (
	"context"
	"testing"
	"time"

	"apskel-pos-be/internal/entities"
	"apskel-pos-be/internal/models"

	"github.com/google/uuid"
	"github.com/stretchr/testify/require"
)

type analyticsRepositoryStub struct {
	purchasingResult *entities.PurchasingAnalytics
	profitLossResult *entities.ProfitLossAnalytics
	profitLossGroup  string
}

func (analyticsRepositoryStub) GetPaymentMethodAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) ([]*entities.PaymentMethodAnalytics, error) {
	return nil, nil
}

func (analyticsRepositoryStub) GetSalesAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, string) ([]*entities.SalesAnalytics, error) {
	return nil, nil
}

func (s analyticsRepositoryStub) GetPurchasingAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, string) (*entities.PurchasingAnalytics, error) {
	return s.purchasingResult, nil
}

func (analyticsRepositoryStub) GetProductAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, int) ([]*entities.ProductAnalytics, error) {
	return nil, nil
}

func (analyticsRepositoryStub) GetProductAnalyticsPerCategory(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) ([]*entities.ProductAnalyticsPerCategory, error) {
	return nil, nil
}

func (analyticsRepositoryStub) GetDashboardOverview(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) (*entities.DashboardOverview, error) {
	return nil, nil
}

func (s analyticsRepositoryStub) GetProfitLossAnalytics(_ context.Context, _ uuid.UUID, _ *uuid.UUID, _, _ time.Time, groupBy string) (*entities.ProfitLossAnalytics, error) {
	s.profitLossGroup = groupBy
	return s.profitLossResult, nil
}

type expenseRepositoryStub struct{}

func (expenseRepositoryStub) Create(context.Context, *entities.Expense) error { return nil }
func (expenseRepositoryStub) GetByID(context.Context, uuid.UUID) (*entities.Expense, error) {
	return nil, nil
}
func (expenseRepositoryStub) GetByIDAndOrganizationID(context.Context, uuid.UUID, uuid.UUID) (*entities.Expense, error) {
	return nil, nil
}
func (expenseRepositoryStub) Update(context.Context, *entities.Expense) error { return nil }
func (expenseRepositoryStub) Delete(context.Context, uuid.UUID) error         { return nil }
func (expenseRepositoryStub) List(context.Context, uuid.UUID, map[string]interface{}, int, int) ([]*entities.Expense, int64, error) {
	return nil, 0, nil
}
func (expenseRepositoryStub) CreateItem(context.Context, *entities.ExpenseItem) error { return nil }
func (expenseRepositoryStub) DeleteItemsByExpenseID(context.Context, uuid.UUID) error { return nil }

func TestAnalyticsProcessorGetPurchasingAnalyticsPassesOutletName(t *testing.T) {
	outletID := uuid.New()
	outletName := "Main Outlet"
	now := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
	processor := NewAnalyticsProcessorImpl(analyticsRepositoryStub{
		purchasingResult: &entities.PurchasingAnalytics{
			OutletName: &outletName,
			Summary: entities.PurchasingSummary{
				TotalPurchases: 125,
			},
		},
	}, expenseRepositoryStub{})

	result, err := processor.GetPurchasingAnalytics(context.Background(), &models.PurchasingAnalyticsRequest{
		OrganizationID: uuid.New(),
		OutletID:       &outletID,
		DateFrom:       now,
		DateTo:         now,
	})

	require.NoError(t, err)
	require.NotNil(t, result)
	require.Equal(t, &outletID, result.OutletID)
	require.NotNil(t, result.OutletName)
	require.Equal(t, outletName, *result.OutletName)
	require.Equal(t, float64(125), result.Summary.TotalPurchases)
}

func TestAnalyticsProcessorGetProfitLossAnalyticsMapsOverviewAndReportFields(t *testing.T) {
	productID := uuid.New()
	categoryID := uuid.New()
	now := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
	processor := NewAnalyticsProcessorImpl(analyticsRepositoryStub{
		profitLossResult: &entities.ProfitLossAnalytics{
			Summary: entities.ProfitLossSummary{
				TotalRevenue:       1000,
				TotalCost:          400,
				GrossProfit:        600,
				GrossProfitMargin:  60,
				TotalTax:           50,
				TotalDiscount:      25,
				NetProfit:          575,
				NetProfitMargin:    57.5,
				TotalOrders:        10,
				AverageProfit:      57.5,
				ProfitabilityRatio: 150,
			},
			Data: []entities.ProfitLossData{
				{
					Date:              now,
					Revenue:           1000,
					Cost:              400,
					GrossProfit:       600,
					GrossProfitMargin: 60,
					Tax:               50,
					Discount:          25,
					NetProfit:         575,
					NetProfitMargin:   57.5,
					Orders:            10,
				},
			},
			ProductData: []entities.ProductProfitData{
				{
					ProductID:         productID,
					ProductName:       "Nasi",
					CategoryID:        categoryID,
					CategoryName:      "Food",
					QuantitySold:      5,
					Revenue:           500,
					Cost:              200,
					GrossProfit:       300,
					GrossProfitMargin: 60,
					AveragePrice:      100,
					AverageCost:       40,
					ProfitPerUnit:     60,
				},
			},
			TodayRevenue: 1000,
			TodayCost:    400,
			MtdRevenue:   2000,
			MtdCost:      800,
		},
	}, expenseRepositoryStub{})

	result, err := processor.GetProfitLossAnalytics(context.Background(), &models.ProfitLossAnalyticsRequest{
		OrganizationID: uuid.New(),
		DateFrom:       now,
		DateTo:         now,
	})

	require.NoError(t, err)
	require.NotNil(t, result)
	require.Equal(t, "day", result.GroupBy)
	require.Equal(t, float64(1000), result.Summary.TotalRevenue)
	require.Len(t, result.Data, 1)
	require.Equal(t, float64(575), result.Data[0].NetProfit)
	require.Len(t, result.ProductData, 1)
	require.Equal(t, productID, result.ProductData[0].ProductID)
	require.NotEmpty(t, result.MainSummary)
	require.Equal(t, "total_omset", result.MainSummary[0].ID)
}