refactor: 重构trustlog-sdk目录结构到trustlog/go-trustlog

- 将所有trustlog-sdk文件移动到trustlog/go-trustlog/目录
- 更新README中所有import路径从trustlog-sdk改为go-trustlog
- 更新cookiecutter配置文件中的项目名称
- 更新根目录.lefthook.yml以引用新位置的配置
- 添加go.sum文件到版本控制
- 删除过时的示例文件

这次重构与trustlog-server保持一致的目录结构,
为未来支持多语言SDK(Python、Java等)预留空间。
This commit is contained in:
ryan
2025-12-22 13:37:57 +08:00
commit d313449c5c
87 changed files with 20622 additions and 0 deletions

423
api/model/envelope_test.go Normal file
View File

@@ -0,0 +1,423 @@
package model_test
import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.yandata.net/iod/iod/trustlog-sdk/api/model"
)
func TestNewEnvelopeConfig(t *testing.T) {
t.Parallel()
signer := model.NewNopSigner()
config := model.NewEnvelopeConfig(signer)
assert.NotNil(t, config.Signer)
}
func TestNewSM2EnvelopeConfig(t *testing.T) {
t.Parallel()
privateKey := []byte("test-private-key")
publicKey := []byte("test-public-key")
config := model.NewSM2EnvelopeConfig(privateKey, publicKey)
assert.NotNil(t, config.Signer)
}
func TestNewVerifyConfig(t *testing.T) {
t.Parallel()
signer := model.NewNopSigner()
config := model.NewVerifyConfig(signer)
assert.NotNil(t, config.Signer)
}
func TestNewSM2VerifyConfig(t *testing.T) {
t.Parallel()
publicKey := []byte("test-public-key")
config := model.NewSM2VerifyConfig(publicKey)
assert.NotNil(t, config.Signer)
}
func TestMarshalEnvelope_Nil(t *testing.T) {
t.Parallel()
_, err := model.MarshalEnvelope(nil)
require.Error(t, err)
assert.Contains(t, err.Error(), "envelope cannot be nil")
}
func TestMarshalEnvelope_Basic(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
assert.NotNil(t, data)
assert.NotEmpty(t, data)
}
func TestMarshalEnvelope_EmptyFields(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "",
Signature: []byte{},
Body: []byte{},
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
assert.NotNil(t, data)
}
func TestUnmarshalEnvelope_Nil(t *testing.T) {
t.Parallel()
_, err := model.UnmarshalEnvelope(nil)
require.Error(t, err)
assert.Contains(t, err.Error(), "data is empty")
}
func TestUnmarshalEnvelope_Empty(t *testing.T) {
t.Parallel()
_, err := model.UnmarshalEnvelope([]byte{})
require.Error(t, err)
assert.Contains(t, err.Error(), "data is empty")
}
func TestMarshalUnmarshalEnvelope_RoundTrip(t *testing.T) {
t.Parallel()
original := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
// Marshal
data, err := model.MarshalEnvelope(original)
require.NoError(t, err)
require.NotNil(t, data)
// Unmarshal
result, err := model.UnmarshalEnvelope(data)
require.NoError(t, err)
require.NotNil(t, result)
// Verify
assert.Equal(t, original.ProducerID, result.ProducerID)
assert.Equal(t, original.Signature, result.Signature)
assert.Equal(t, original.Body, result.Body)
}
func TestUnmarshalEnvelopeProducerID(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
producerID, err := model.UnmarshalEnvelopeProducerID(data)
require.NoError(t, err)
assert.Equal(t, "producer-1", producerID)
}
func TestUnmarshalEnvelopeSignature(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
producerID, signature, err := model.UnmarshalEnvelopeSignature(data)
require.NoError(t, err)
assert.Equal(t, "producer-1", producerID)
assert.Equal(t, []byte("signature"), signature)
}
func TestUnmarshalEnvelopeSignature_EmptyData(t *testing.T) {
t.Parallel()
_, _, err := model.UnmarshalEnvelopeSignature(nil)
require.Error(t, err)
assert.Contains(t, err.Error(), "data is empty")
}
func TestUnmarshalEnvelopeSignature_InvalidData(t *testing.T) {
t.Parallel()
_, _, err := model.UnmarshalEnvelopeSignature([]byte{0xff, 0xff})
require.Error(t, err)
}
func TestUnmarshalEnvelopeProducerID_EmptyData(t *testing.T) {
t.Parallel()
_, err := model.UnmarshalEnvelopeProducerID(nil)
require.Error(t, err)
assert.Contains(t, err.Error(), "data is empty")
}
func TestMarshalTrustlog_Nil(t *testing.T) {
t.Parallel()
_, err := model.MarshalTrustlog(nil, model.EnvelopeConfig{})
require.Error(t, err)
assert.Contains(t, err.Error(), "trustlog cannot be nil")
}
func TestMarshalTrustlog_Basic(t *testing.T) {
t.Parallel()
op := &model.Operation{
OpID: "op-123",
Timestamp: time.Now(),
OpSource: model.OpSourceIRP,
OpType: model.OpTypeOCCreateHandle,
DoPrefix: "test",
DoRepository: "repo",
Doid: "test/repo/123",
ProducerID: "producer-1",
OpActor: "actor-1",
}
err := op.CheckAndInit()
require.NoError(t, err)
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalTrustlog(op, config)
require.NoError(t, err)
assert.NotNil(t, data)
}
func TestUnmarshalTrustlog_Nil(t *testing.T) {
t.Parallel()
op := &model.Operation{}
err := model.UnmarshalTrustlog(nil, op)
require.Error(t, err)
assert.Contains(t, err.Error(), "data is empty")
}
func TestMarshalOperation(t *testing.T) {
t.Parallel()
op := &model.Operation{
OpID: "op-123",
Timestamp: time.Now(),
OpSource: model.OpSourceIRP,
OpType: model.OpTypeOCCreateHandle,
DoPrefix: "test",
DoRepository: "repo",
Doid: "test/repo/123",
ProducerID: "producer-1",
OpActor: "actor-1",
}
err := op.CheckAndInit()
require.NoError(t, err)
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalOperation(op, config)
require.NoError(t, err)
assert.NotNil(t, data)
}
func TestUnmarshalOperation(t *testing.T) {
t.Parallel()
op := &model.Operation{
OpID: "op-123",
Timestamp: time.Now(),
OpSource: model.OpSourceIRP,
OpType: model.OpTypeOCCreateHandle,
DoPrefix: "test",
DoRepository: "repo",
Doid: "test/repo/123",
ProducerID: "producer-1",
OpActor: "actor-1",
}
err := op.CheckAndInit()
require.NoError(t, err)
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalOperation(op, config)
require.NoError(t, err)
result, err := model.UnmarshalOperation(data)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, op.OpID, result.OpID)
}
func TestMarshalRecord(t *testing.T) {
t.Parallel()
rec := &model.Record{
ID: "rec-123",
DoPrefix: "test",
ProducerID: "producer-1",
Timestamp: time.Now(),
Operator: "operator-1",
Extra: []byte("extra"),
RCType: "log",
}
err := rec.CheckAndInit()
require.NoError(t, err)
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalRecord(rec, config)
require.NoError(t, err)
assert.NotNil(t, data)
}
func TestUnmarshalRecord(t *testing.T) {
t.Parallel()
rec := &model.Record{
ID: "rec-123",
DoPrefix: "test",
ProducerID: "producer-1",
Timestamp: time.Now(),
Operator: "operator-1",
Extra: []byte("extra"),
RCType: "log",
}
err := rec.CheckAndInit()
require.NoError(t, err)
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalRecord(rec, config)
require.NoError(t, err)
result, err := model.UnmarshalRecord(data)
require.NoError(t, err)
assert.NotNil(t, result)
assert.Equal(t, rec.ID, result.ID)
}
func TestVerifyEnvelope_Nil(t *testing.T) {
t.Parallel()
config := model.NewEnvelopeConfig(model.NewNopSigner())
env, err := model.VerifyEnvelope(nil, config)
require.Error(t, err)
assert.Nil(t, env)
assert.Contains(t, err.Error(), "data is empty")
}
func TestVerifyEnvelope_Basic(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
config := model.NewEnvelopeConfig(model.NewNopSigner())
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
verifiedEnv, err := model.VerifyEnvelope(data, config)
// NopSigner verifies by comparing body with signature
// Since signature != body, verification should fail
require.Error(t, err)
assert.Nil(t, verifiedEnv)
}
func TestVerifyEnvelopeWithConfig_Nil(t *testing.T) {
t.Parallel()
config := model.NewVerifyConfig(model.NewNopSigner())
env, err := model.VerifyEnvelopeWithConfig(nil, config)
require.Error(t, err)
assert.Nil(t, env)
// Error message may vary, just check that it's an error
assert.NotEmpty(t, err.Error())
}
func TestVerifyEnvelopeWithConfig_NilSigner(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
config := model.VerifyConfig{Signer: nil}
verifiedEnv, err := model.VerifyEnvelopeWithConfig(data, config)
require.Error(t, err)
assert.Nil(t, verifiedEnv)
assert.Contains(t, err.Error(), "signer is required")
}
func TestVerifyEnvelopeWithConfig_Success(t *testing.T) {
t.Parallel()
// Create envelope with matching body and signature (NopSigner requirement)
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("body"), // Same as body for NopSigner
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
config := model.NewVerifyConfig(model.NewNopSigner())
verifiedEnv, err := model.VerifyEnvelopeWithConfig(data, config)
require.NoError(t, err)
require.NotNil(t, verifiedEnv)
assert.Equal(t, env.ProducerID, verifiedEnv.ProducerID)
assert.Equal(t, env.Signature, verifiedEnv.Signature)
assert.Equal(t, env.Body, verifiedEnv.Body)
}
func TestVerifyEnvelope_NilSigner(t *testing.T) {
t.Parallel()
env := &model.Envelope{
ProducerID: "producer-1",
Signature: []byte("signature"),
Body: []byte("body"),
}
data, err := model.MarshalEnvelope(env)
require.NoError(t, err)
config := model.EnvelopeConfig{Signer: nil}
verifiedEnv, err := model.VerifyEnvelope(data, config)
require.Error(t, err)
assert.Nil(t, verifiedEnv)
assert.Contains(t, err.Error(), "signer is required")
}