idk/go-i2p
1
0
Fork 0
mirror of https://github.com/go-i2p/go-i2p.git synced 2025-07-05 06:05:16 -04:00
Code Issues Packages Projects Releases Wiki Activity

improving tests with testify, unexporting sorting types

Browse Source
This commit is contained in:
Hayden Parker
2016-03-28 22:16:52 -07:00
parent 3e89c54630
commit fc9b661ce6
5 changed files with 161 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

110
lib/common/key_certificate_test.go
View File

@ -1,125 +1,127 @@
package common
import (
"github.com/stretchr/testify/assert"
"testing"
)
func TestSingingPublicKeyTypeReturnsCorrectInteger(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x03, 0x00, 0x00})
pk_type, err := key_cert.SigningPublicKeyType()
if err != nil {
t.Fatal("err reading SigningPublicKey type on valid data:", err)
}
if pk_type != KEYCERT_SIGN_P521 {
t.Fatal("SigningPublicKeyType did not return correct type:", pk_type)
}
assert.Nil(err, "SigningPublicKeyType() returned error with valid data")
assert.Equal(pk_type, KEYCERT_SIGN_P521, "SigningPublicKeyType() did not return correct typec")
}
func TestSingingPublicKeyTypeReportsWhenDataTooSmall(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x01, 0x00})
_, err := key_cert.SigningPublicKeyType()
if err == nil || err.Error() != "error parsing key certificate: not enough data" {
t.Fatal("incorrect error reported by SigningPublicKeyType:", err)
if assert.NotNil(err) {
assert.Equal("error parsing key certificate: not enough data", err.Error(), "correct error message should be returned")
}
}
func TestPublicKeyTypeReturnsCorrectInteger(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x03})
pk_type, err := key_cert.PublicKeyType()
if err != nil {
t.Fatal("err reading PublicKey type on valid data:", err)
}
if pk_type != KEYCERT_SIGN_P521 {
t.Fatal("PublicKeyType did not return correct type:", pk_type)
}
assert.Nil(err, "PublicKey() returned error with valid data")
assert.Equal(pk_type, KEYCERT_SIGN_P521, "PublicKeyType() did not return correct typec")
}
func TestPublicKeyTypeReportsWhenDataTooSmall(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x02, 0x00, 0x00})
_, err := key_cert.PublicKeyType()
if err == nil || err.Error() != "error parsing key certificate: not enough data" {
t.Fatal("incorrect error reported by PublicKeyType:", err)
if assert.NotNil(err) {
assert.Equal("error parsing key certificate: not enough data", err.Error(), "correct error message should be returned")
}
}
func TestConstructPublicKeyReportsWhenDataTooSmall(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00})
data := make([]byte, 255)
_, err := key_cert.ConstructPublicKey(data)
if err == nil || err.Error() != "error constructing public key: not enough data" {
t.Fatal("ConstructPubliKey reported incorrect error with missing data:", err)
if assert.NotNil(err) {
assert.Equal("error constructing public key: not enough data", err.Error(), "correct error message should be returned")
}
}
func TestConstructPublicKeyReturnsCorrectDataWithElg(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00})
data := make([]byte, 256)
pk, err := key_cert.ConstructPublicKey(data)
if err != nil {
t.Fatal("ConstructPublicKey returned error with valid data:", err)
}
if pk.Len() != 256 {
t.Fatal("ConstructPublicKey did not return public key with correct length")
}
assert.Nil(err, "ConstructPublicKey() returned error with valid data")
assert.Equal(pk.Len(), 256, "ConstructPublicKey() did not return public key with correct length")
}
func TestConstructSigningPublicKeyReportsWhenDataTooSmall(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00})
data := make([]byte, 127)
_, err := key_cert.ConstructSigningPublicKey(data)
if err == nil || err.Error() != "error constructing signing public key: not enough data" {
t.Fatal("ConstructSigngingPubliKey reported incorrect error with missing data:", err)
if assert.NotNil(err) {
assert.Equal("error constructing signing public key: not enough data", err.Error(), "correct error message should be returned")
}
}
func TestConstructSigningPublicKeyWithDSASHA1(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00})
data := make([]byte, 128)
spk, err := key_cert.ConstructSigningPublicKey(data)
if err != nil {
t.Fatal("ConstructSigningPublicKey with DSA SHA1 returned err on valid data:", err)
}
spk_len := spk.Len()
if spk_len != KEYCERT_SIGN_DSA_SHA1_SIZE {
t.Fatal("ConstructSigningPublicKeyWithDSASHA1 returned incorrect SigningPublicKey length:", spk_len)
}
assert.Nil(err, "ConstructSigningPublicKey() with DSA SHA1 returned error with valid data")
assert.Equal(spk.Len(), KEYCERT_SIGN_DSA_SHA1_SIZE, "ConstructSigningPublicKey() with DSA SHA1 returned incorrect SigningPublicKey length")
}
func TestConstructSigningPublicKeyWithP256(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x01, 0x00, 0x01})
data := make([]byte, 128)
spk, err := key_cert.ConstructSigningPublicKey(data)
if err != nil {
t.Fatal("ConstructSigningPublicKey with P256 returned err on valid data:", err)
}
spk_len := spk.Len()
if spk_len != KEYCERT_SIGN_P256_SIZE {
t.Fatal("ConstructSigningPublicKey with P256 returned incorrect SigningPublicKey length:", spk_len)
}
assert.Nil(err, "ConstructSigningPublicKey() with P256 returned err on valid data")
assert.Equal(spk.Len(), KEYCERT_SIGN_P256_SIZE, "ConstructSigningPublicKey() with P256 returned incorrect SigningPublicKey length")
}
func TestConstructSigningPublicKeyWithP384(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x04, 0x00, 0x02, 0x00, 0x02})
data := make([]byte, 128)
spk, err := key_cert.ConstructSigningPublicKey(data)
if err != nil {
t.Fatal("ConstructSigningPublicKey with P384 returned err on valid data:", err)
}
spk_len := spk.Len()
if spk_len != KEYCERT_SIGN_P384_SIZE {
t.Fatal("ConstructSigningPublicKey with P384 returned incorrect SigningPublicKey length:", spk_len)
}
assert.Nil(err, "ConstructSigningPublicKey() with P384 returned err on valid data")
assert.Equal(spk.Len(), KEYCERT_SIGN_P384_SIZE, "ConstructSigningPublicKey() with P384 returned incorrect SigningPublicKey length")
}
func TestConstructSigningPublicKeyWithP521(t *testing.T) {
assert := assert.New(t)
key_cert := KeyCertificate([]byte{0x05, 0x00, 0x08, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00})
data := make([]byte, 128)
spk, err := key_cert.ConstructSigningPublicKey(data)
if err != nil {
t.Fatal("ConstructSigningPublicKey with P521 returned err on valid data:", err)
}
spk_len := spk.Len()
if spk_len != KEYCERT_SIGN_P521_SIZE {
t.Fatal("ConstructSigningPublicKey with P521 returned incorrect SigningPublicKey length:", spk_len)
}
assert.Nil(err, "ConstructSigningPublicKey() with P521 returned err on valid data")
assert.Equal(spk.Len(), KEYCERT_SIGN_P521_SIZE, "ConstructSigningPublicKey() with P521 returned incorrect SigningPublicKey length")
}