platforms/backend/api/internal/seed/mock_test.go

package seed

import (
	"regexp"
	"testing"

	"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/common"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
)

func TestMockEntityIdentitiesAreStableAndUnique(t *testing.T) {
	identityPattern := regexp.MustCompile(
		`^00000000-0000-7000-8000-[0-9]{12}$`,
	)
	seen := make(map[string]struct{}, 46)
	for sequence := 1; sequence <= 46; sequence++ {
		record := entity(sequence, common.StatusEnable)
		if !identityPattern.MatchString(record.Identity) {
			t.Fatalf("entity(%d) identity = %q", sequence, record.Identity)
		}
		if _, exists := seen[record.Identity]; exists {
			t.Fatalf("duplicate identity %q", record.Identity)
		}
		seen[record.Identity] = struct{}{}
		if record.Status != common.StatusEnable {
			t.Fatalf("entity(%d) has unexpected defaults: %#v", sequence, record)
		}
	}
}

// TestLinkMockProductProducer 验证未来 Mock 智能气阀始终关联已落库生产商。
func TestLinkMockProductProducer(t *testing.T) {
	product := models.ProductInfo{}
	producer := models.ProducerAccount{Entity: models.Entity{ID: 9}}
	if err := linkMockProductProducer(&product, producer); err != nil {
		t.Fatalf("关联 Mock 生产商失败：%v", err)
	}
	if product.ProducerAccountID != producer.ID {
		t.Fatalf("生产商关联错误：got %d, want %d", product.ProducerAccountID, producer.ID)
	}
	if err := linkMockProductProducer(&models.ProductInfo{}, models.ProducerAccount{}); err == nil {
		t.Fatal("未落库生产商不应建立 Mock 关联")
	}
}

func TestIdentityOfEmbeddedEntity(t *testing.T) {
	record := struct {
		Entity struct {
			Identity string
		}
	}{}
	record.Entity.Identity = "mock-identity"
	if got := identityOf(&record); got != record.Entity.Identity {
		t.Fatalf("identityOf() = %q, want %q", got, record.Entity.Identity)
	}
	if got := identityOf(nil); got != "" {
		t.Fatalf("identityOf(nil) = %q, want empty", got)
	}
}

func TestIdentityOfDirectIdentityField(t *testing.T) {
	record := struct {
		Identity string
	}{Identity: "mock-direct-identity"}
	if got := identityOf(&record); got != record.Identity {
		t.Fatalf("identityOf() = %q, want %q", got, record.Identity)
	}
}

func TestAdditionalScenarioIdentitiesDoNotOverlapBaseScenario(t *testing.T) {
	seen := make(map[string]struct{}, 226)
	for sequence := 1; sequence <= 56; sequence++ {
		seen[entity(sequence, common.StatusEnable).Identity] = struct{}{}
	}
	for scenario := 2; scenario <= 10; scenario++ {
		base := 1000 + scenario*100
		for offset := 1; offset <= 20; offset++ {
			identity := entity(base+offset, common.StatusEnable).Identity
			if _, exists := seen[identity]; exists {
				t.Fatalf("duplicate identity %q", identity)
			}
			seen[identity] = struct{}{}
		}
	}
}