133 lines
4.7 KiB
Go
133 lines
4.7 KiB
Go
package identity_test
|
|
|
|
import "seekia/internal/identity"
|
|
|
|
import "seekia/internal/encoding"
|
|
import "seekia/internal/helpers"
|
|
|
|
import "testing"
|
|
import "bytes"
|
|
|
|
func TestRandomIdentity(t *testing.T){
|
|
|
|
randomIdentityType, err := helpers.GetRandomItemFromList([]string{"Mate", "Host", "Moderator"})
|
|
if (err != nil){
|
|
t.Fatalf("Failed to get random identityType: " + err.Error())
|
|
}
|
|
|
|
testIdentityHash, err := identity.GetNewRandomIdentityHash(true, randomIdentityType)
|
|
if (err != nil){
|
|
t.Fatalf("GetNewRandomIdentityHash failed: " + err.Error())
|
|
}
|
|
|
|
identityType, err := identity.GetIdentityTypeFromIdentityHash(testIdentityHash)
|
|
if (err != nil){
|
|
t.Fatalf("GetNewRandomIdentityHash returning invalid identity hash. Reason: " + err.Error())
|
|
}
|
|
|
|
if (identityType != randomIdentityType){
|
|
t.Fatalf("GetNewRandomIdentityHash returning identity hash of different identityType: " + identityType)
|
|
}
|
|
}
|
|
|
|
func TestIdentityDerivation(t *testing.T){
|
|
|
|
testSeedPhraseHashHex := "6c63469b0581a2633d37721d466b68ed9c3b3744352a5409792f84e24d19203d"
|
|
|
|
testSeedPhraseHashBytes, err := encoding.DecodeHexStringToBytes(testSeedPhraseHashHex)
|
|
if (err != nil){
|
|
t.Fatalf("testSeedPhraseHashHex is invalid: Not Hex: " + err.Error())
|
|
}
|
|
|
|
testSeedPhraseHashArray := [32]byte(testSeedPhraseHashBytes)
|
|
|
|
expectedPublicIdentityKeyHex := "69b6735f22a3991215a139a666dcbb42e7a33fbab32109a185dd60ba2a5a150d"
|
|
|
|
expectedPublicIdentityKeyBytes, err := encoding.DecodeHexStringToBytes(expectedPublicIdentityKeyHex)
|
|
if (err != nil){
|
|
t.Fatalf("expectedPublicIdentityKeyHex is invalid: Not Hex: " + err.Error())
|
|
}
|
|
|
|
expectedPrivateIdentityKeyHex := "38a84046125d37b00343c281a91ea3e9b7edee50b82df2b5350b66f44985423369b6735f22a3991215a139a666dcbb42e7a33fbab32109a185dd60ba2a5a150d"
|
|
|
|
expectedPrivateIdentityKeyBytes, err := encoding.DecodeHexStringToBytes(expectedPrivateIdentityKeyHex)
|
|
if (err != nil){
|
|
t.Fatalf("expectedPrivateIdentityKeyHex is invalid: Not Hex: " + err.Error())
|
|
}
|
|
|
|
publicIdentityKey, privateIdentityKey, err := identity.GetPublicPrivateIdentityKeysFromSeedPhraseHash(testSeedPhraseHashArray)
|
|
if (err != nil){
|
|
t.Fatalf("GetPublicPrivateIdentityKeysFromSeedPhraseHash failed: " + err.Error())
|
|
}
|
|
areEqual := bytes.Equal(publicIdentityKey[:], expectedPublicIdentityKeyBytes)
|
|
if (areEqual == false){
|
|
publicKeyHex := encoding.EncodeBytesToHexString(publicIdentityKey[:])
|
|
t.Fatalf("GetPublicPrivateIdentityKeysFromSeedPhraseHash returning invalid public identity key: " + publicKeyHex)
|
|
}
|
|
areEqual = bytes.Equal(privateIdentityKey[:], expectedPrivateIdentityKeyBytes)
|
|
if (areEqual == false){
|
|
privateKeyHex := encoding.EncodeBytesToHexString(privateIdentityKey[:])
|
|
t.Fatalf("GetPublicPrivateIdentityKeysFromSeedPhraseHash returning invalid private identity key: " + privateKeyHex)
|
|
}
|
|
|
|
identityHash, err := identity.ConvertIdentityKeyToIdentityHash(publicIdentityKey, "Mate")
|
|
if (err != nil){
|
|
t.Fatalf("ConvertIdentityKeyToIdentityHash failed: " + err.Error())
|
|
}
|
|
|
|
expectedIdentityHash := "orvstztt4hp6rqjcpv2icocf5dm"
|
|
|
|
expectedIdentityHashArray, identityType, err := identity.ReadIdentityHashString(expectedIdentityHash)
|
|
if (err != nil){
|
|
t.Fatalf("Cannot read expectedIdentityHash: " + err.Error())
|
|
}
|
|
|
|
if (identityHash != expectedIdentityHashArray){
|
|
|
|
identityHashString, _, err := identity.EncodeIdentityHashBytesToString(identityHash)
|
|
if (err != nil){
|
|
t.Fatalf("ConvertIdentityKeyToIdentityHash returning invalid identity hash: " + err.Error())
|
|
}
|
|
|
|
t.Fatalf("ReadIdentityHashString returning unexpected identity hash: " + identityHashString)
|
|
}
|
|
if (identityType != "Mate"){
|
|
t.Fatalf("ReadIdentityHashString returning unexpected identityType: " + identityType)
|
|
}
|
|
|
|
identityType, err = identity.GetIdentityTypeFromIdentityHash(identityHash)
|
|
if (err != nil){
|
|
t.Fatalf("GetIdentityTypeFromIdentityHash fails to read valid mate identity hash.")
|
|
}
|
|
|
|
if (identityType != "Mate"){
|
|
t.Fatalf("GetIdentityTypeFromIdentityHash fails to read valid mate identity hash.")
|
|
}
|
|
|
|
}
|
|
|
|
|
|
func TestIdentityEncoding(t *testing.T){
|
|
|
|
testIdentityHash, err := identity.GetNewRandomIdentityHash(false, "")
|
|
if (err != nil){
|
|
t.Fatalf("GetNewRandomIdentityHash failed: " + err.Error())
|
|
}
|
|
|
|
encodedIdentityHash, identityType, err := identity.EncodeIdentityHashBytesToString(testIdentityHash)
|
|
if (err != nil){
|
|
t.Fatalf("EncodeIdentityHashBytesToString failed: " + err.Error())
|
|
}
|
|
|
|
identityHashBytes, identityType_Received, err := identity.ReadIdentityHashString(encodedIdentityHash)
|
|
if (err != nil){
|
|
t.Fatalf("ReadIdentityHash failed: " + err.Error())
|
|
}
|
|
|
|
if (testIdentityHash != identityHashBytes){
|
|
t.Fatalf("Decoded identity hash does not match.")
|
|
}
|
|
if (identityType != identityType_Received){
|
|
t.Fatalf("Decoded identityType does not match.")
|
|
}
|
|
}
|