mirror of
https://github.com/QuilibriumNetwork/ceremonyclient.git
synced 2026-02-21 18:37:26 +08:00
dbd95bd9e9
* v2.1.0 [omit consensus and adjacent] - this commit will be amended with the full release after the file copy is complete * 2.1.0 main node rollup
553 lines
14 KiB
Go
553 lines
14 KiB
Go
package protobufs
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestHypergraphConfiguration_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
config *HypergraphConfiguration
|
|
}{
|
|
{
|
|
name: "complete configuration",
|
|
config: &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 57), // Ed448 key
|
|
WritePublicKey: make([]byte, 57), // Ed448 key
|
|
},
|
|
},
|
|
{
|
|
name: "empty keys",
|
|
config: &HypergraphConfiguration{
|
|
ReadPublicKey: []byte{},
|
|
WritePublicKey: []byte{},
|
|
},
|
|
},
|
|
{
|
|
name: "different keys",
|
|
config: &HypergraphConfiguration{
|
|
ReadPublicKey: append([]byte{0x01}, make([]byte, 56)...),
|
|
WritePublicKey: append([]byte{0x02}, make([]byte, 56)...),
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.config.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
config2 := &HypergraphConfiguration{}
|
|
err = config2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
assert.Equal(t, tt.config.ReadPublicKey, config2.ReadPublicKey)
|
|
assert.Equal(t, tt.config.WritePublicKey, config2.WritePublicKey)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHypergraphDeploy_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
deploy *HypergraphDeploy
|
|
}{
|
|
{
|
|
name: "complete deploy",
|
|
deploy: &HypergraphDeploy{
|
|
Config: &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 57),
|
|
WritePublicKey: make([]byte, 57),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.deploy.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
deploy2 := &HypergraphDeploy{}
|
|
err = deploy2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
require.NotNil(t, deploy2.Config)
|
|
assert.Equal(t, tt.deploy.Config.ReadPublicKey, deploy2.Config.ReadPublicKey)
|
|
assert.Equal(t, tt.deploy.Config.WritePublicKey, deploy2.Config.WritePublicKey)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVertexAdd_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
vertex *VertexAdd
|
|
}{
|
|
{
|
|
name: "complete vertex",
|
|
vertex: &VertexAdd{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Data: []byte("test vector commitment tree data"),
|
|
Signature: make([]byte, 114), // Ed448 signature
|
|
},
|
|
},
|
|
{
|
|
name: "minimal vertex",
|
|
vertex: &VertexAdd{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Data: []byte{0x01},
|
|
Signature: []byte{},
|
|
},
|
|
},
|
|
{
|
|
name: "large data",
|
|
vertex: &VertexAdd{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Data: make([]byte, 1024), // Large data blob
|
|
Signature: make([]byte, 114),
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.vertex.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
vertex2 := &VertexAdd{}
|
|
err = vertex2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
assert.Equal(t, tt.vertex.Domain, vertex2.Domain)
|
|
assert.Equal(t, tt.vertex.DataAddress, vertex2.DataAddress)
|
|
assert.Equal(t, tt.vertex.Data, vertex2.Data)
|
|
assert.Equal(t, tt.vertex.Signature, vertex2.Signature)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVertexRemove_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
vertex *VertexRemove
|
|
}{
|
|
{
|
|
name: "complete vertex remove",
|
|
vertex: &VertexRemove{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Signature: make([]byte, 114),
|
|
},
|
|
},
|
|
{
|
|
name: "empty signature",
|
|
vertex: &VertexRemove{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Signature: []byte{},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.vertex.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
vertex2 := &VertexRemove{}
|
|
err = vertex2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
assert.Equal(t, tt.vertex.Domain, vertex2.Domain)
|
|
assert.Equal(t, tt.vertex.DataAddress, vertex2.DataAddress)
|
|
assert.Equal(t, tt.vertex.Signature, vertex2.Signature)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHyperedgeAdd_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
hyperedge *HyperedgeAdd
|
|
}{
|
|
{
|
|
name: "complete hyperedge",
|
|
hyperedge: &HyperedgeAdd{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte("hyperedge value data"),
|
|
Signature: make([]byte, 114),
|
|
},
|
|
},
|
|
{
|
|
name: "minimal hyperedge",
|
|
hyperedge: &HyperedgeAdd{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte{0x01},
|
|
Signature: []byte{},
|
|
},
|
|
},
|
|
{
|
|
name: "large value",
|
|
hyperedge: &HyperedgeAdd{
|
|
Domain: make([]byte, 32),
|
|
Value: make([]byte, 2048),
|
|
Signature: make([]byte, 114),
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.hyperedge.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
hyperedge2 := &HyperedgeAdd{}
|
|
err = hyperedge2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
assert.Equal(t, tt.hyperedge.Domain, hyperedge2.Domain)
|
|
assert.Equal(t, tt.hyperedge.Value, hyperedge2.Value)
|
|
assert.Equal(t, tt.hyperedge.Signature, hyperedge2.Signature)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHyperedgeRemove_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
hyperedge *HyperedgeRemove
|
|
}{
|
|
{
|
|
name: "complete hyperedge remove",
|
|
hyperedge: &HyperedgeRemove{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte("hyperedge value to remove"),
|
|
Signature: make([]byte, 114),
|
|
},
|
|
},
|
|
{
|
|
name: "minimal value",
|
|
hyperedge: &HyperedgeRemove{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte{0x01},
|
|
Signature: []byte{},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.hyperedge.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
hyperedge2 := &HyperedgeRemove{}
|
|
err = hyperedge2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare
|
|
assert.Equal(t, tt.hyperedge.Domain, hyperedge2.Domain)
|
|
assert.Equal(t, tt.hyperedge.Value, hyperedge2.Value)
|
|
assert.Equal(t, tt.hyperedge.Signature, hyperedge2.Signature)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHypergraphTypes_Validation(t *testing.T) {
|
|
t.Run("HypergraphConfiguration validation", func(t *testing.T) {
|
|
// Valid configuration
|
|
config := &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 57),
|
|
WritePublicKey: make([]byte, 57),
|
|
}
|
|
assert.NoError(t, config.Validate())
|
|
|
|
// Invalid read key length
|
|
config.ReadPublicKey = make([]byte, 56)
|
|
assert.Error(t, config.Validate())
|
|
|
|
// Invalid write key length
|
|
config.ReadPublicKey = make([]byte, 57)
|
|
config.WritePublicKey = make([]byte, 58)
|
|
assert.Error(t, config.Validate())
|
|
|
|
// Nil configuration
|
|
var nilConfig *HypergraphConfiguration
|
|
assert.Error(t, nilConfig.Validate())
|
|
})
|
|
|
|
t.Run("HypergraphDeploy validation", func(t *testing.T) {
|
|
// Valid deploy
|
|
deploy := &HypergraphDeploy{
|
|
Config: &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 57),
|
|
WritePublicKey: make([]byte, 57),
|
|
},
|
|
}
|
|
assert.NoError(t, deploy.Validate())
|
|
|
|
// Nil config
|
|
deploy.Config = nil
|
|
assert.Error(t, deploy.Validate())
|
|
|
|
// Invalid config
|
|
deploy.Config = &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 56),
|
|
WritePublicKey: make([]byte, 57),
|
|
}
|
|
assert.Error(t, deploy.Validate())
|
|
})
|
|
|
|
t.Run("VertexAdd validation", func(t *testing.T) {
|
|
// Valid vertex
|
|
vertex := &VertexAdd{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Data: []byte("test"),
|
|
Signature: make([]byte, 114),
|
|
}
|
|
assert.NoError(t, vertex.Validate())
|
|
|
|
// Invalid domain length
|
|
vertex.Domain = make([]byte, 31)
|
|
assert.Error(t, vertex.Validate())
|
|
|
|
// Invalid data address length
|
|
vertex.Domain = make([]byte, 32)
|
|
vertex.DataAddress = make([]byte, 33)
|
|
assert.Error(t, vertex.Validate())
|
|
|
|
// Empty data
|
|
vertex.DataAddress = make([]byte, 32)
|
|
vertex.Data = []byte{}
|
|
assert.Error(t, vertex.Validate())
|
|
|
|
// Empty signature
|
|
vertex.Data = []byte("test")
|
|
vertex.Signature = []byte{}
|
|
assert.Error(t, vertex.Validate())
|
|
})
|
|
|
|
t.Run("VertexRemove validation", func(t *testing.T) {
|
|
// Valid vertex remove
|
|
vertex := &VertexRemove{
|
|
Domain: make([]byte, 32),
|
|
DataAddress: make([]byte, 32),
|
|
Signature: make([]byte, 114),
|
|
}
|
|
assert.NoError(t, vertex.Validate())
|
|
|
|
// Invalid domain length
|
|
vertex.Domain = make([]byte, 31)
|
|
assert.Error(t, vertex.Validate())
|
|
|
|
// Empty signature
|
|
vertex.Domain = make([]byte, 32)
|
|
vertex.Signature = []byte{}
|
|
assert.Error(t, vertex.Validate())
|
|
})
|
|
|
|
t.Run("HyperedgeAdd validation", func(t *testing.T) {
|
|
// Valid hyperedge
|
|
hyperedge := &HyperedgeAdd{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte("test"),
|
|
Signature: make([]byte, 114),
|
|
}
|
|
assert.NoError(t, hyperedge.Validate())
|
|
|
|
// Invalid domain length
|
|
hyperedge.Domain = make([]byte, 31)
|
|
assert.Error(t, hyperedge.Validate())
|
|
|
|
// Empty value
|
|
hyperedge.Domain = make([]byte, 32)
|
|
hyperedge.Value = []byte{}
|
|
assert.Error(t, hyperedge.Validate())
|
|
|
|
// Empty signature
|
|
hyperedge.Value = []byte("test")
|
|
hyperedge.Signature = []byte{}
|
|
assert.Error(t, hyperedge.Validate())
|
|
})
|
|
|
|
t.Run("HyperedgeRemove validation", func(t *testing.T) {
|
|
// Valid hyperedge remove
|
|
hyperedge := &HyperedgeRemove{
|
|
Domain: make([]byte, 32),
|
|
Value: []byte("test"),
|
|
Signature: make([]byte, 114),
|
|
}
|
|
assert.NoError(t, hyperedge.Validate())
|
|
|
|
// Invalid domain length
|
|
hyperedge.Domain = make([]byte, 31)
|
|
assert.Error(t, hyperedge.Validate())
|
|
|
|
// Empty value
|
|
hyperedge.Domain = make([]byte, 32)
|
|
hyperedge.Value = []byte{}
|
|
assert.Error(t, hyperedge.Validate())
|
|
})
|
|
}
|
|
|
|
func TestHypergraphSerialization_RoundTrip(t *testing.T) {
|
|
// Test that serialize -> deserialize -> serialize produces the same bytes
|
|
config := &HypergraphConfiguration{
|
|
ReadPublicKey: randomBytes(t, 57),
|
|
WritePublicKey: randomBytes(t, 57),
|
|
}
|
|
|
|
// First serialization
|
|
data1, err := config.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
|
|
// Deserialize
|
|
config2 := &HypergraphConfiguration{}
|
|
err = config2.FromCanonicalBytes(data1)
|
|
require.NoError(t, err)
|
|
|
|
// Second serialization
|
|
data2, err := config2.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
|
|
// Should be identical
|
|
assert.Equal(t, data1, data2)
|
|
}
|
|
|
|
func TestHypergraphUpdate_Serialization(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
update *HypergraphUpdate
|
|
}{
|
|
{
|
|
name: "complete hypergraph update",
|
|
update: &HypergraphUpdate{
|
|
Config: &HypergraphConfiguration{
|
|
ReadPublicKey: make([]byte, 57),
|
|
WritePublicKey: make([]byte, 57),
|
|
},
|
|
RdfSchema: []byte("@prefix ex: <http://example.org/> . ex:Thing a ex:Class ."),
|
|
PublicKeySignatureBls48581: &BLS48581AggregateSignature{
|
|
Signature: make([]byte, 74), // BLS48-581 aggregate signature size
|
|
PublicKey: &BLS48581G2PublicKey{
|
|
KeyValue: make([]byte, 585), // BLS48-581 G2 public key size
|
|
},
|
|
Bitmask: make([]byte, 32),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "update with config only",
|
|
update: &HypergraphUpdate{
|
|
Config: &HypergraphConfiguration{
|
|
ReadPublicKey: append([]byte{0xAA}, make([]byte, 56)...),
|
|
WritePublicKey: append([]byte{0xBB}, make([]byte, 56)...),
|
|
},
|
|
RdfSchema: []byte{},
|
|
PublicKeySignatureBls48581: &BLS48581AggregateSignature{
|
|
Signature: append([]byte{0xCC}, make([]byte, 73)...),
|
|
PublicKey: &BLS48581G2PublicKey{
|
|
KeyValue: append([]byte{0xDD}, make([]byte, 584)...),
|
|
},
|
|
Bitmask: append([]byte{0xEE}, make([]byte, 31)...),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "update with schema only",
|
|
update: &HypergraphUpdate{
|
|
Config: nil,
|
|
RdfSchema: []byte("@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> ."),
|
|
PublicKeySignatureBls48581: &BLS48581AggregateSignature{
|
|
Signature: make([]byte, 74),
|
|
PublicKey: &BLS48581G2PublicKey{
|
|
KeyValue: make([]byte, 585),
|
|
},
|
|
Bitmask: make([]byte, 32),
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "minimal update",
|
|
update: &HypergraphUpdate{
|
|
Config: nil,
|
|
RdfSchema: []byte{},
|
|
PublicKeySignatureBls48581: nil,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test serialization
|
|
data, err := tt.update.ToCanonicalBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, data)
|
|
|
|
// Test deserialization
|
|
update2 := &HypergraphUpdate{}
|
|
err = update2.FromCanonicalBytes(data)
|
|
require.NoError(t, err)
|
|
|
|
// Compare basic fields
|
|
assert.Equal(t, true, bytes.Equal(tt.update.RdfSchema, update2.RdfSchema))
|
|
|
|
// Compare Config if present
|
|
if tt.update.Config != nil {
|
|
assert.NotNil(t, update2.Config)
|
|
assert.Equal(t, tt.update.Config.ReadPublicKey, update2.Config.ReadPublicKey)
|
|
assert.Equal(t, tt.update.Config.WritePublicKey, update2.Config.WritePublicKey)
|
|
} else {
|
|
assert.Nil(t, update2.Config)
|
|
}
|
|
|
|
// Compare signature if present
|
|
if tt.update.PublicKeySignatureBls48581 != nil {
|
|
assert.NotNil(t, update2.PublicKeySignatureBls48581)
|
|
assert.Equal(t, tt.update.PublicKeySignatureBls48581.Signature, update2.PublicKeySignatureBls48581.Signature)
|
|
assert.Equal(t, tt.update.PublicKeySignatureBls48581.Bitmask, update2.PublicKeySignatureBls48581.Bitmask)
|
|
|
|
if tt.update.PublicKeySignatureBls48581.PublicKey != nil {
|
|
assert.NotNil(t, update2.PublicKeySignatureBls48581.PublicKey)
|
|
assert.Equal(t, tt.update.PublicKeySignatureBls48581.PublicKey.KeyValue, update2.PublicKeySignatureBls48581.PublicKey.KeyValue)
|
|
} else {
|
|
assert.Nil(t, update2.PublicKeySignatureBls48581.PublicKey)
|
|
}
|
|
} else {
|
|
assert.Nil(t, update2.PublicKeySignatureBls48581)
|
|
}
|
|
})
|
|
}
|
|
}
|