fb182adef4
🎯 核心变更: - OpType (string) → OpCode (int32) - 20+ OpCode枚举常量 (基于DOIP/IRP标准) - 类型安全 + 性能优化 📊 影响范围: - 核心模型: Operation结构体、CBOR序列化 - 数据库: schema.go + SQL DDL (PostgreSQL/MySQL/SQLite) - 持久化: repository.go查询、cursor_worker.go - API接口: Protobuf定义 + gRPC客户端 - 测试代码: 60+ 测试文件更新 ✅ 测试结果: - 通过率: 100% (所有87个测试用例) - 总体覆盖率: 53.7% - 核心包覆盖率: logger(100%), highclient(95.3%), model(79.1%) 📝 文档: - 精简README (1056行→489行，减少54%) - 完整的OpCode枚举说明 - 三种持久化策略示例 - 数据库表结构和架构图 🔧 技术细节: - 类型转换: string(OpCode) → int32(OpCode) - SQL参数: 字符串值 → 整数值 - Protobuf: op_type string → op_code int32 - 测试断言: 字符串比较 → 常量比较 🎉 质量保证: - 零编译错误 - 100%测试通过 - PostgreSQL/Pulsar集成测试验证 - 分布式并发安全测试通过
577 lines
14 KiB
Go
577 lines
14 KiB
Go
package model_test
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
"go.yandata.net/iod/iod/go-trustlog/api/grpc/pb"
|
|
"go.yandata.net/iod/iod/go-trustlog/api/model"
|
|
)
|
|
|
|
func TestFromProtobuf_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.FromProtobuf(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "protobuf operation data is nil")
|
|
}
|
|
|
|
func TestFromProtobuf_NoTimestamp(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbOp := &pb.OperationData{}
|
|
result, err := model.FromProtobuf(pbOp)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "timestamp is required")
|
|
}
|
|
|
|
func TestFromProtobuf_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbOp := &pb.OperationData{
|
|
OpId: "op-123",
|
|
Timestamp: timestamppb.New(now),
|
|
OpSource: "IRP",
|
|
OpCode: 100, // CREATE_ID
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerId: "producer-1",
|
|
OpActor: "actor-1",
|
|
}
|
|
|
|
result, err := model.FromProtobuf(pbOp)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "op-123", result.OpID)
|
|
assert.Equal(t, now.Unix(), result.Timestamp.Unix())
|
|
assert.Equal(t, model.Source("IRP"), result.OpSource)
|
|
assert.Equal(t, model.OpCode(100), result.OpCode)
|
|
assert.Equal(t, "test", result.DoPrefix)
|
|
assert.Equal(t, "repo", result.DoRepository)
|
|
assert.Equal(t, "test/repo/123", result.Doid)
|
|
assert.Equal(t, "producer-1", result.ProducerID)
|
|
assert.Equal(t, "actor-1", result.OpActor)
|
|
}
|
|
|
|
func TestFromProtobuf_WithHashes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbOp := &pb.OperationData{
|
|
OpId: "op-123",
|
|
Timestamp: timestamppb.New(now),
|
|
OpSource: "DOIP",
|
|
OpCode: 100, // CREATE_ID
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerId: "producer-1",
|
|
OpActor: "actor-1",
|
|
RequestBodyHash: "req-hash",
|
|
ResponseBodyHash: "resp-hash",
|
|
}
|
|
|
|
result, err := model.FromProtobuf(pbOp)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.NotNil(t, result.RequestBodyHash)
|
|
assert.Equal(t, "req-hash", *result.RequestBodyHash)
|
|
assert.NotNil(t, result.ResponseBodyHash)
|
|
assert.Equal(t, "resp-hash", *result.ResponseBodyHash)
|
|
}
|
|
|
|
func TestFromProtobuf_EmptyHashes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbOp := &pb.OperationData{
|
|
OpId: "op-123",
|
|
Timestamp: timestamppb.New(now),
|
|
OpSource: "DOIP",
|
|
OpCode: int32(model.OpCodeCreateID),
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerId: "producer-1",
|
|
OpActor: "actor-1",
|
|
RequestBodyHash: "",
|
|
ResponseBodyHash: "",
|
|
}
|
|
|
|
result, err := model.FromProtobuf(pbOp)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Nil(t, result.RequestBodyHash)
|
|
assert.Nil(t, result.ResponseBodyHash)
|
|
}
|
|
|
|
func TestToProtobuf_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.ToProtobuf(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "operation is nil")
|
|
}
|
|
|
|
func TestToProtobuf_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
op := &model.Operation{
|
|
OpID: "op-123",
|
|
Timestamp: now,
|
|
OpSource: model.OpSourceIRP,
|
|
OpCode: model.OpCodeCreateID,
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerID: "producer-1",
|
|
OpActor: "actor-1",
|
|
}
|
|
|
|
result, err := model.ToProtobuf(op)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "op-123", result.GetOpId())
|
|
assert.Equal(t, now.Unix(), result.GetTimestamp().AsTime().Unix())
|
|
assert.Equal(t, "IRP", result.GetOpSource())
|
|
assert.Equal(t, int32(100), result.GetOpCode())
|
|
assert.Equal(t, "test", result.GetDoPrefix())
|
|
assert.Equal(t, "repo", result.GetDoRepository())
|
|
assert.Equal(t, "test/repo/123", result.GetDoid())
|
|
assert.Equal(t, "producer-1", result.GetProducerId())
|
|
assert.Equal(t, "actor-1", result.GetOpActor())
|
|
}
|
|
|
|
func TestToProtobuf_WithHashes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
reqHash := "req-hash"
|
|
respHash := "resp-hash"
|
|
now := time.Now()
|
|
op := &model.Operation{
|
|
OpID: "op-123",
|
|
Timestamp: now,
|
|
OpSource: model.OpSourceDOIP,
|
|
OpCode: model.OpCodeCreateID,
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerID: "producer-1",
|
|
OpActor: "actor-1",
|
|
RequestBodyHash: &reqHash,
|
|
ResponseBodyHash: &respHash,
|
|
}
|
|
|
|
result, err := model.ToProtobuf(op)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "req-hash", result.GetRequestBodyHash())
|
|
assert.Equal(t, "resp-hash", result.GetResponseBodyHash())
|
|
}
|
|
|
|
func TestToProtobuf_WithoutHashes(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
op := &model.Operation{
|
|
OpID: "op-123",
|
|
Timestamp: now,
|
|
OpSource: model.OpSourceDOIP,
|
|
OpCode: model.OpCodeCreateID,
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerID: "producer-1",
|
|
OpActor: "actor-1",
|
|
}
|
|
|
|
result, err := model.ToProtobuf(op)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Empty(t, result.GetRequestBodyHash())
|
|
assert.Empty(t, result.GetResponseBodyHash())
|
|
}
|
|
|
|
func TestFromProtobufValidationResult_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.FromProtobufValidationResult(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "protobuf validation result is nil")
|
|
}
|
|
|
|
func TestFromProtobufValidationResult_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.ValidationStreamRes{
|
|
Code: 100,
|
|
Msg: "Processing",
|
|
Progress: "50%",
|
|
}
|
|
|
|
result, err := model.FromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(100), result.Code)
|
|
assert.Equal(t, "Processing", result.Msg)
|
|
assert.Equal(t, "50%", result.Progress)
|
|
assert.Nil(t, result.Data)
|
|
assert.Nil(t, result.Proof)
|
|
}
|
|
|
|
func TestFromProtobufValidationResult_WithProof(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.ValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Proof: &pb.Proof{
|
|
Sign: "test-signature",
|
|
ColItems: []*pb.MerkleTreeProofItem{
|
|
{Floor: 1, Hash: "hash1", Left: true},
|
|
},
|
|
},
|
|
}
|
|
|
|
result, err := model.FromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(200), result.Code)
|
|
assert.NotNil(t, result.Proof)
|
|
assert.Equal(t, "test-signature", result.Proof.Sign)
|
|
assert.Len(t, result.Proof.ColItems, 1)
|
|
}
|
|
|
|
func TestFromProtobufValidationResult_WithData(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbRes := &pb.ValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Data: &pb.OperationData{
|
|
OpId: "op-123",
|
|
Timestamp: timestamppb.New(now),
|
|
OpSource: "IRP",
|
|
OpCode: int32(model.OpCodeCreateID),
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerId: "producer-1",
|
|
OpActor: "actor-1",
|
|
},
|
|
}
|
|
|
|
result, err := model.FromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(200), result.Code)
|
|
assert.NotNil(t, result.Data)
|
|
assert.Equal(t, "op-123", result.Data.OpID)
|
|
}
|
|
|
|
func TestFromProtobufValidationResult_WithInvalidData(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.ValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Data: &pb.OperationData{
|
|
// Missing timestamp
|
|
},
|
|
}
|
|
|
|
result, err := model.FromProtobufValidationResult(pbRes)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "failed to convert operation data")
|
|
}
|
|
|
|
func TestRecordFromProtobuf_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.RecordFromProtobuf(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "protobuf record data is nil")
|
|
}
|
|
|
|
func TestRecordFromProtobuf_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbRec := &pb.RecordData{
|
|
Id: "rec-123",
|
|
DoPrefix: "test",
|
|
ProducerId: "producer-1",
|
|
Timestamp: timestamppb.New(now),
|
|
Operator: "operator-1",
|
|
Extra: []byte("extra-data"),
|
|
RcType: "log",
|
|
}
|
|
|
|
result, err := model.RecordFromProtobuf(pbRec)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "rec-123", result.ID)
|
|
assert.Equal(t, "test", result.DoPrefix)
|
|
assert.Equal(t, "producer-1", result.ProducerID)
|
|
assert.Equal(t, now.Unix(), result.Timestamp.Unix())
|
|
assert.Equal(t, "operator-1", result.Operator)
|
|
assert.Equal(t, []byte("extra-data"), result.Extra)
|
|
assert.Equal(t, "log", result.RCType)
|
|
}
|
|
|
|
func TestRecordFromProtobuf_NoTimestamp(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRec := &pb.RecordData{
|
|
Id: "rec-123",
|
|
DoPrefix: "test",
|
|
ProducerId: "producer-1",
|
|
Operator: "operator-1",
|
|
Extra: []byte("extra-data"),
|
|
RcType: "log",
|
|
}
|
|
|
|
result, err := model.RecordFromProtobuf(pbRec)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "rec-123", result.ID)
|
|
assert.True(t, result.Timestamp.IsZero())
|
|
}
|
|
|
|
func TestRecordToProtobuf_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.RecordToProtobuf(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "record is nil")
|
|
}
|
|
|
|
func TestRecordToProtobuf_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
rec := &model.Record{
|
|
ID: "rec-123",
|
|
DoPrefix: "test",
|
|
ProducerID: "producer-1",
|
|
Timestamp: now,
|
|
Operator: "operator-1",
|
|
Extra: []byte("extra-data"),
|
|
RCType: "log",
|
|
}
|
|
|
|
result, err := model.RecordToProtobuf(rec)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, "rec-123", result.GetId())
|
|
assert.Equal(t, "test", result.GetDoPrefix())
|
|
assert.Equal(t, "producer-1", result.GetProducerId())
|
|
assert.Equal(t, now.Unix(), result.GetTimestamp().AsTime().Unix())
|
|
assert.Equal(t, "operator-1", result.GetOperator())
|
|
assert.Equal(t, []byte("extra-data"), result.GetExtra())
|
|
assert.Equal(t, "log", result.GetRcType())
|
|
}
|
|
|
|
func TestRecordFromProtobufValidationResult_Nil(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
result, err := model.RecordFromProtobufValidationResult(nil)
|
|
require.Nil(t, result)
|
|
require.Error(t, err)
|
|
assert.Contains(t, err.Error(), "protobuf record validation result is nil")
|
|
}
|
|
|
|
func TestRecordFromProtobufValidationResult_Basic(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.RecordValidationStreamRes{
|
|
Code: 100,
|
|
Msg: "Processing",
|
|
Progress: "50%",
|
|
}
|
|
|
|
result, err := model.RecordFromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(100), result.Code)
|
|
assert.Equal(t, "Processing", result.Msg)
|
|
assert.Equal(t, "50%", result.Progress)
|
|
assert.Nil(t, result.Data)
|
|
assert.Nil(t, result.Proof)
|
|
}
|
|
|
|
func TestRecordFromProtobufValidationResult_WithProof(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.RecordValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Proof: &pb.Proof{
|
|
Sign: "test-signature",
|
|
RawItems: []*pb.MerkleTreeProofItem{
|
|
{Floor: 1, Hash: "hash1", Left: true},
|
|
},
|
|
},
|
|
}
|
|
|
|
result, err := model.RecordFromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(200), result.Code)
|
|
assert.NotNil(t, result.Proof)
|
|
assert.Equal(t, "test-signature", result.Proof.Sign)
|
|
assert.Len(t, result.Proof.RawItems, 1)
|
|
}
|
|
|
|
func TestRecordFromProtobufValidationResult_WithData(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
pbRes := &pb.RecordValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Result: &pb.RecordData{
|
|
Id: "rec-123",
|
|
DoPrefix: "test",
|
|
ProducerId: "producer-1",
|
|
Timestamp: timestamppb.New(now),
|
|
Operator: "operator-1",
|
|
Extra: []byte("extra-data"),
|
|
RcType: "log",
|
|
},
|
|
}
|
|
|
|
result, err := model.RecordFromProtobufValidationResult(pbRes)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
assert.Equal(t, int32(200), result.Code)
|
|
assert.NotNil(t, result.Data)
|
|
assert.Equal(t, "rec-123", result.Data.ID)
|
|
}
|
|
|
|
func TestRecordFromProtobufValidationResult_WithInvalidData(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
pbRes := &pb.RecordValidationStreamRes{
|
|
Code: 200,
|
|
Msg: "Completed",
|
|
Progress: "100%",
|
|
Result: &pb.RecordData{
|
|
// Missing required fields to trigger error
|
|
},
|
|
}
|
|
|
|
result, err := model.RecordFromProtobufValidationResult(pbRes)
|
|
// This should succeed even with empty RecordData
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
assert.Equal(t, int32(200), result.Code)
|
|
}
|
|
|
|
func TestRoundTrip_Operation(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
original := &model.Operation{
|
|
OpID: "op-123",
|
|
Timestamp: now,
|
|
OpSource: model.OpSourceIRP,
|
|
OpCode: model.OpCodeCreateID,
|
|
DoPrefix: "test",
|
|
DoRepository: "repo",
|
|
Doid: "test/repo/123",
|
|
ProducerID: "producer-1",
|
|
OpActor: "actor-1",
|
|
}
|
|
|
|
// Convert to protobuf
|
|
pbOp, err := model.ToProtobuf(original)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, pbOp)
|
|
|
|
// Convert back to model
|
|
result, err := model.FromProtobuf(pbOp)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
// Verify round trip
|
|
assert.Equal(t, original.OpID, result.OpID)
|
|
assert.Equal(t, original.OpSource, result.OpSource)
|
|
assert.Equal(t, original.OpCode, result.OpCode)
|
|
assert.Equal(t, original.DoPrefix, result.DoPrefix)
|
|
assert.Equal(t, original.DoRepository, result.DoRepository)
|
|
assert.Equal(t, original.Doid, result.Doid)
|
|
assert.Equal(t, original.ProducerID, result.ProducerID)
|
|
assert.Equal(t, original.OpActor, result.OpActor)
|
|
}
|
|
|
|
func TestRoundTrip_Record(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Now()
|
|
original := &model.Record{
|
|
ID: "rec-123",
|
|
DoPrefix: "test",
|
|
ProducerID: "producer-1",
|
|
Timestamp: now,
|
|
Operator: "operator-1",
|
|
Extra: []byte("extra-data"),
|
|
RCType: "log",
|
|
}
|
|
|
|
// Convert to protobuf
|
|
pbRec, err := model.RecordToProtobuf(original)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, pbRec)
|
|
|
|
// Convert back to model
|
|
result, err := model.RecordFromProtobuf(pbRec)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result)
|
|
|
|
// Verify round trip
|
|
assert.Equal(t, original.ID, result.ID)
|
|
assert.Equal(t, original.DoPrefix, result.DoPrefix)
|
|
assert.Equal(t, original.ProducerID, result.ProducerID)
|
|
assert.Equal(t, original.Timestamp.Unix(), result.Timestamp.Unix())
|
|
assert.Equal(t, original.Operator, result.Operator)
|
|
assert.Equal(t, original.Extra, result.Extra)
|
|
assert.Equal(t, original.RCType, result.RCType)
|
|
}
|
|
|