More tests

core/good_key_test.go

@@ -15,15 +15,22 @@ import (
 	"github.com/letsencrypt/boulder/test"
 )
 
+func TestUnknownKeyType(t *testing.T) {
+	notAKey := struct{}{}
+	test.Assert(t, !GoodKey(notAKey), "Should have rejeected a key of unknown type")
+}
+
 func TestWrongKeyType(t *testing.T) {
 	ecdsaKey := ecdsa.PublicKey{}
 	test.Assert(t, !GoodKey(&ecdsaKey), "Should have rejected ECDSA key.")
+	test.Assert(t, !GoodKey(ecdsaKey), "Should have rejected ECDSA key.")
 }
 
 func TestSmallModulus(t *testing.T) {
 	private, err := rsa.GenerateKey(rand.Reader, 2040)
 	test.AssertNotError(t, err, "Error generating key")
 	test.Assert(t, !GoodKey(&private.PublicKey), "Should have rejected too-short key.")
+	test.Assert(t, !GoodKey(private.PublicKey), "Should have rejected too-short key.")
 }
 
 func TestSmallExponent(t *testing.T) {

core/objects_test.go

@@ -6,11 +6,32 @@
 package core
 
 import (
+	"encoding/json"
+	"net/url"
 	"testing"
 
 	"github.com/letsencrypt/boulder/test"
 )
 
+func TestRegistrationUupdate(t *testing.T) {
+	oldURL, _ := url.Parse("http://old.invalid")
+	newURL, _ := url.Parse("http://new.invalid")
+
+	reg := Registration{
+		ID:        1,
+		Contact:   []AcmeURL{AcmeURL(*oldURL)},
+		Agreement: "",
+	}
+	update := Registration{
+		Contact:   []AcmeURL{AcmeURL(*newURL)},
+		Agreement: "totally!",
+	}
+
+	reg.MergeUpdate(update)
+	test.Assert(t, len(reg.Contact) == 1 && reg.Contact[0] == update.Contact[0], "Contact was not updated %v != %v")
+	test.Assert(t, reg.Agreement == update.Agreement, "Agreement was not updated")
+}
+
 func TestSanityCheck(t *testing.T) {
 	chall := Challenge{Type: ChallengeTypeSimpleHTTPS, Status: StatusValid}
 	test.Assert(t, !chall.IsSane(false), "IsSane should be false")
@@ -58,4 +79,18 @@ func TestSanityCheck(t *testing.T) {
 	test.Assert(t, !chall.IsSane(true), "IsSane should be false")
 	chall.S = "KQqLsiS5j0CONR_eUXTUSUDNVaHODtc-0pD6ACif7U4"
 	test.Assert(t, chall.IsSane(true), "IsSane should be true")
+
+	chall = Challenge{Type: "bogus", Status: StatusPending}
+	test.Assert(t, !chall.IsSane(false), "IsSane should be false")
+	test.Assert(t, !chall.IsSane(true), "IsSane should be false")
+}
+
+func TestJsonBufferUnmarshal(t *testing.T) {
+	testStruct := struct {
+		Buffer JsonBuffer
+	}{}
+
+	notValidBase64 := []byte(`{"Buffer":"!!!!"}`)
+	err := json.Unmarshal(notValidBase64, &testStruct)
+	test.Assert(t, err != nil, "Should have choked on invalid base64")
 }

core/util_test.go

@@ -6,10 +6,13 @@
 package core
 
 import (
+	"encoding/json"
 	"fmt"
+	"github.com/letsencrypt/boulder/Godeps/_workspace/src/github.com/square/go-jose"
 	"github.com/letsencrypt/boulder/test"
 	"math"
 	"math/big"
+	"net/url"
 	"testing"
 )
 
@@ -31,11 +34,6 @@ func TestNewToken(t *testing.T) {
 	return
 }
 
-func TestRandString(t *testing.T) {
-	// This is covered by NewToken
-	return
-}
-
 func TestSerialUtils(t *testing.T) {
 	serial := SerialToString(big.NewInt(100000000000000000))
 	test.AssertEquals(t, serial, "0000000000000000016345785d8a0000")
@@ -52,3 +50,49 @@ func TestSerialUtils(t *testing.T) {
 func TestBuildID(t *testing.T) {
 	test.AssertEquals(t, "Unspecified", GetBuildID())
 }
+
+const JWK_1_JSON = `{
+  "kty": "RSA",
+  "n": "vuc785P8lBj3fUxyZchF_uZw6WtbxcorqgTyq-qapF5lrO1U82Tp93rpXlmctj6fyFHBVVB5aXnUHJ7LZeVPod7Wnfl8p5OyhlHQHC8BnzdzCqCMKmWZNX5DtETDId0qzU7dPzh0LP0idt5buU7L9QNaabChw3nnaL47iu_1Di5Wp264p2TwACeedv2hfRDjDlJmaQXuS8Rtv9GnRWyC9JBu7XmGvGDziumnJH7Hyzh3VNu-kSPQD3vuAFgMZS6uUzOztCkT0fpOalZI6hqxtWLvXUMj-crXrn-Maavz8qRhpAyp5kcYk3jiHGgQIi7QSK2JIdRJ8APyX9HlmTN5AQ",
+  "e": "AAEAAQ"
+}`
+const JWK_1_DIGEST = `ul04Iq07ulKnnrebv2hv3yxCGgVvoHs8hjq2tVKx3mc=`
+const JWK_2_JSON = `{
+  "kty":"RSA",
+  "n":"yTsLkI8n4lg9UuSKNRC0UPHsVjNdCYk8rGXIqeb_rRYaEev3D9-kxXY8HrYfGkVt5CiIVJ-n2t50BKT8oBEMuilmypSQqJw0pCgtUm-e6Z0Eg3Ly6DMXFlycyikegiZ0b-rVX7i5OCEZRDkENAYwFNX4G7NNCwEZcH7HUMUmty9dchAqDS9YWzPh_dde1A9oy9JMH07nRGDcOzIh1rCPwc71nwfPPYeeS4tTvkjanjeigOYBFkBLQuv7iBB4LPozsGF1XdoKiIIi-8ye44McdhOTPDcQp3xKxj89aO02pQhBECv61rmbPinvjMG9DYxJmZvjsKF4bN2oy0DxdC1jDw",
+  "e":"AAEAAQ"
+}`
+
+func TestKeyDigest(t *testing.T) {
+	// Test with JWK (value, reference, and direct)
+	var jwk jose.JsonWebKey
+	json.Unmarshal([]byte(JWK_1_JSON), &jwk)
+	digest, err := KeyDigest(jwk)
+	test.Assert(t, err == nil && digest == JWK_1_DIGEST, "Failed to digest JWK by value")
+	digest, err = KeyDigest(&jwk)
+	test.Assert(t, err == nil && digest == JWK_1_DIGEST, "Failed to digest JWK by reference")
+	digest, err = KeyDigest(jwk.Key)
+	test.Assert(t, err == nil && digest == JWK_1_DIGEST, "Failed to digest bare key")
+
+	// Test with unknown key type
+	digest, err = KeyDigest(struct{}{})
+	test.Assert(t, err != nil, "Should have rejected unknown key type")
+}
+
+func TestKeyDigestEquals(t *testing.T) {
+	var jwk1, jwk2 jose.JsonWebKey
+	json.Unmarshal([]byte(JWK_1_JSON), &jwk1)
+	json.Unmarshal([]byte(JWK_2_JSON), &jwk2)
+
+	test.Assert(t, KeyDigestEquals(jwk1, jwk1), "Key digests for same key should match")
+	test.Assert(t, !KeyDigestEquals(jwk1, jwk2), "Key digests for different keys should not match")
+	test.Assert(t, !KeyDigestEquals(jwk1, struct{}{}), "Unknown key types should not match anything")
+	test.Assert(t, !KeyDigestEquals(struct{}{}, struct{}{}), "Unknown key types should not match anything")
+}
+
+func TestAcmeURL(t *testing.T) {
+	s := "http://example.invalid"
+	u, _ := url.Parse(s)
+	a := AcmeURL(*u)
+	test.AssertEquals(t, s, a.String())
+}