droboticflow/internal/store/data_operations_test.go
2026-08-18 11:35:44 +08:00

201 lines
7.0 KiB
Go

package store
import (
"context"
"testing"
"droboticflow/internal/domain"
)
func dataOperationsInt64(value int64) *int64 {
return &value
}
func dataOperationsFloat64(value float64) *float64 {
return &value
}
func TestMemoryDataOperationsSummarySeparatesConsumptionAndUniqueData(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
task := domain.CollectionTaskRecord{
ID: "task-y1",
OrganizationID: domain.DefaultOrganizationID,
ProjectID: "project-y1",
Name: "Y1 桌面整理",
RobotModel: "Y1",
Scene: "桌面整理",
Status: domain.CollectionTaskStatusActive,
Targets: domain.DataVolume{TrajectoryCount: dataOperationsInt64(100)},
}
if err := dataStore.UpsertCollectionTask(ctx, task); err != nil {
t.Fatalf("upsert task: %v", err)
}
for _, item := range []domain.DataMetricFactRecord{
{
ID: "fact-collect",
SourceKey: "run-collect/node/1/collect",
OrganizationID: domain.DefaultOrganizationID,
ProjectID: "project-y1",
TaskID: task.ID,
TaskName: task.Name,
RobotModel: "Y1",
Scene: "桌面整理",
RunID: "run-collect",
NodeID: "collect",
Attempt: 1,
Stage: domain.DataMetricStageCollect,
Output: domain.DataVolume{
TrajectoryCount: dataOperationsInt64(40),
DurationSeconds: dataOperationsFloat64(1200),
},
Quality: domain.DataMetricQualityExact,
OccurredAt: "2026-07-23T01:00:00Z",
},
{
ID: "fact-train-1",
SourceKey: "run-train-1/node/1/train",
OrganizationID: domain.DefaultOrganizationID,
ProjectID: "project-y1",
TaskID: task.ID,
RunID: "run-train-1",
NodeID: "train",
Attempt: 1,
Stage: domain.DataMetricStageTrain,
Input: domain.DataVolume{TrajectoryCount: dataOperationsInt64(40)},
TrainingInputs: []domain.TrainingInputRecord{{
DatasetVersionID: "dataset-version-y1",
Split: "train",
Volume: domain.DataVolume{TrajectoryCount: dataOperationsInt64(40)},
}},
Quality: domain.DataMetricQualityExact,
OccurredAt: "2026-07-23T02:00:00Z",
},
{
ID: "fact-train-2",
SourceKey: "run-train-2/node/1/train",
OrganizationID: domain.DefaultOrganizationID,
ProjectID: "project-y1",
TaskID: task.ID,
RunID: "run-train-2",
NodeID: "train",
Attempt: 1,
Stage: domain.DataMetricStageTrain,
Input: domain.DataVolume{TrajectoryCount: dataOperationsInt64(40)},
TrainingInputs: []domain.TrainingInputRecord{{
DatasetVersionID: "dataset-version-y1",
Split: "train",
Volume: domain.DataVolume{TrajectoryCount: dataOperationsInt64(40)},
}},
Quality: domain.DataMetricQualityDerived,
OccurredAt: "2026-07-23T03:00:00Z",
},
} {
if err := dataStore.UpsertDataMetricFact(ctx, item); err != nil {
t.Fatalf("upsert fact %s: %v", item.ID, err)
}
}
summary, err := dataStore.GetDataOperationsSummary(ctx, domain.DefaultOrganizationID, domain.DataOperationsQuery{
From: "2026-07-22T16:00:00Z",
To: "2026-07-23T16:00:00Z",
Timezone: "Asia/Shanghai",
})
if err != nil {
t.Fatalf("get summary: %v", err)
}
if summary.Training.Consumed.TrajectoryCount == nil || *summary.Training.Consumed.TrajectoryCount != 80 {
t.Fatalf("consumed trajectories = %#v, want 80", summary.Training.Consumed.TrajectoryCount)
}
if summary.Training.Unique.TrajectoryCount == nil || *summary.Training.Unique.TrajectoryCount != 40 {
t.Fatalf("unique trajectories = %#v, want 40", summary.Training.Unique.TrajectoryCount)
}
if summary.Training.RunCount != 2 {
t.Fatalf("training run count = %d, want 2", summary.Training.RunCount)
}
if len(summary.Tasks) != 1 || summary.Tasks[0].Percent != 40 {
t.Fatalf("task progress = %#v, want 40 percent", summary.Tasks)
}
if summary.ExactCount != 2 || summary.DerivedCount != 1 {
t.Fatalf("quality counts = exact %d derived %d", summary.ExactCount, summary.DerivedCount)
}
}
func TestMemoryDataMetricUpsertIsIdempotent(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
item := domain.DataMetricFactRecord{
ID: "fact-one",
SourceKey: "run/node/1/collect",
OrganizationID: domain.DefaultOrganizationID,
RunID: "run",
NodeID: "node",
Attempt: 1,
Stage: domain.DataMetricStageCollect,
Output: domain.DataVolume{TrajectoryCount: dataOperationsInt64(10)},
Quality: domain.DataMetricQualityDerived,
OccurredAt: "2026-07-23T01:00:00Z",
}
if err := dataStore.UpsertDataMetricFact(ctx, item); err != nil {
t.Fatalf("first upsert: %v", err)
}
item.ID = "fact-two"
item.Output = domain.DataVolume{TrajectoryCount: dataOperationsInt64(12)}
if err := dataStore.UpsertDataMetricFact(ctx, item); err != nil {
t.Fatalf("second upsert: %v", err)
}
page, err := dataStore.ListDataMetricFactsPage(ctx, domain.DefaultOrganizationID, domain.DataOperationsQuery{
From: "2026-07-23T00:00:00Z",
To: "2026-07-24T00:00:00Z",
})
if err != nil {
t.Fatalf("list facts: %v", err)
}
if len(page.Items) != 1 || page.Items[0].Output.TrajectoryCount == nil || *page.Items[0].Output.TrajectoryCount != 12 {
t.Fatalf("idempotent items = %#v", page.Items)
}
}
func TestTaskProgressPercentSupportsFileCountTargets(t *testing.T) {
target := domain.DataVolume{FileCount: dataOperationsInt64(4)}
collected := domain.DataVolume{FileCount: dataOperationsInt64(3)}
if percent := taskProgressPercent(target, collected); percent != 75 {
t.Fatalf("file-count progress = %v, want 75", percent)
}
}
func TestMemoryExactDataMetricIsNotDowngradedByBackfill(t *testing.T) {
ctx := context.Background()
dataStore := NewMemoryStore()
exact := domain.DataMetricFactRecord{
ID: "fact-exact",
SourceKey: "run/node/1/collect",
OrganizationID: domain.DefaultOrganizationID,
RunID: "run",
NodeID: "node",
Attempt: 1,
Stage: domain.DataMetricStageCollect,
Output: domain.DataVolume{TrajectoryCount: dataOperationsInt64(10)},
Quality: domain.DataMetricQualityExact,
OccurredAt: "2026-07-23T01:00:00Z",
}
if err := dataStore.UpsertDataMetricFact(ctx, exact); err != nil {
t.Fatalf("upsert exact fact: %v", err)
}
estimated := exact
estimated.ID = "fact-estimated"
estimated.Output = domain.DataVolume{TrajectoryCount: dataOperationsInt64(3)}
estimated.Quality = domain.DataMetricQualityEstimated
if err := dataStore.UpsertDataMetricFact(ctx, estimated); err != nil {
t.Fatalf("upsert estimated fact: %v", err)
}
page, err := dataStore.ListDataMetricFactsPage(ctx, domain.DefaultOrganizationID, domain.DataOperationsQuery{})
if err != nil {
t.Fatalf("list facts: %v", err)
}
if len(page.Items) != 1 || page.Items[0].Quality != domain.DataMetricQualityExact ||
page.Items[0].Output.TrajectoryCount == nil || *page.Items[0].Output.TrajectoryCount != 10 {
t.Fatalf("facts = %#v", page.Items)
}
}