Merge e347a8a into 2ff3aa1

common_test.go

@@ -1,12 +1,10 @@
 package mls
 
 import (
-	"bytes"
 	"encoding/hex"
-	"fmt"
-	"reflect"
-	"runtime"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 type TestEnum uint8
@@ -19,10 +17,10 @@ var (
 
 func TestValidateEnum(t *testing.T) {
 	err := validateEnum(TestEnumVal0, TestEnumVal0, TestEnumVal1)
-	assertNotError(t, err, "Failed to recognize known enum value")
+	require.Nil(t, err)
 
 	err = validateEnum(TestEnumInvalid, TestEnumVal0, TestEnumVal1)
-	assertError(t, err, "Failed to flag invalid enum value")
+	require.Error(t, err)
 }
 
 //////////
@@ -34,80 +32,3 @@ func unhex(h string) []byte {
 	}
 	return b
 }
-
-//////////
-
-func assertTrue(t *testing.T, test bool, msg string) {
-	t.Helper()
-	prefix := string("")
-	for i := 1; ; i++ {
-		_, file, line, ok := runtime.Caller(i)
-		if !ok {
-			break
-		}
-		prefix = fmt.Sprintf("%v: %d\n", file, line) + prefix
-	}
-	if !test {
-		t.Fatalf(prefix + msg)
-	}
-}
-
-func assertError(t *testing.T, err error, msg string) {
-	t.Helper()
-	assertTrue(t, err != nil, msg)
-}
-
-func assertNotError(t *testing.T, err error, msg string) {
-	t.Helper()
-	if err != nil {
-		msg += ": " + err.Error()
-	}
-	assertTrue(t, err == nil, msg)
-}
-
-func assertPanic(t *testing.T, f func(), msg string) {
-	defer func() {
-		if r := recover(); r == nil {
-			assertTrue(t, false, msg)
-		}
-	}()
-
-	f()
-}
-
-func assertNil(t *testing.T, x interface{}, msg string) {
-	t.Helper()
-	assertTrue(t, x == nil, msg)
-}
-
-func assertNotNil(t *testing.T, x interface{}, msg string) {
-	t.Helper()
-	assertTrue(t, x != nil, msg)
-}
-
-func assertEquals(t *testing.T, a, b interface{}) {
-	t.Helper()
-	assertTrue(t, a == b, fmt.Sprintf("%+v != %+v", a, b))
-}
-
-func assertByteEquals(t *testing.T, a, b []byte) {
-	t.Helper()
-	assertTrue(t, bytes.Equal(a, b), fmt.Sprintf("%+v != %+v", hex.EncodeToString(a), hex.EncodeToString(b)))
-}
-
-func assertNotByteEquals(t *testing.T, a, b []byte) {
-	t.Helper()
-	assertTrue(t, !bytes.Equal(a, b), fmt.Sprintf("%+v == %+v", hex.EncodeToString(a), hex.EncodeToString(b)))
-}
-
-func assertDeepEquals(t *testing.T, a, b interface{}) {
-	t.Helper()
-	assertTrue(t, reflect.DeepEqual(a, b), fmt.Sprintf("%+v != %+v", a, b))
-}
-
-func assertSameType(t *testing.T, a, b interface{}) {
-	t.Helper()
-	A := reflect.TypeOf(a)
-	B := reflect.TypeOf(b)
-	assertTrue(t, A == B, fmt.Sprintf("%s != %s", A.Name(), B.Name()))
-}

credential_test.go

@@ -2,29 +2,31 @@ package mls
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestBasicCredential(t *testing.T) {
 	identity := []byte("res ipsa")
 	scheme := Ed25519
 	priv, err := scheme.Generate()
-	assertNotError(t, err, "Error generating private key")
+	require.Nil(t, err)
 
 	cred := NewBasicCredential(identity, scheme, &priv)
-	assertTrue(t, cred.Equals(*cred), "Credential not equal to self")
-	assertEquals(t, cred.Type(), CredentialTypeBasic)
-	assertEquals(t, cred.Scheme(), scheme)
-	assertDeepEquals(t, *cred.PublicKey(), priv.PublicKey)
+	require.True(t, cred.Equals(*cred))
+	require.Equal(t, cred.Type(), CredentialTypeBasic)
+	require.Equal(t, cred.Scheme(), scheme)
+	require.Equal(t, *cred.PublicKey(), priv.PublicKey)
 }
 
 func TestCredentialErrorCases(t *testing.T) {
 	cred0 := Credential{nil, nil}
 
-	assertTrue(t, !cred0.Equals(cred0), "Bad credentials should not be equal")
-	assertEquals(t, cred0.Type(), CredentialTypeInvalid)
-	assertPanic(t, func() { cred0.PublicKey() }, "Public key for bad credential")
-	assertPanic(t, func() { cred0.Scheme() }, "Scheme for bad credential")
+	require.True(t, !cred0.Equals(cred0))
+	require.Equal(t, cred0.Type(), CredentialTypeInvalid)
+	require.Panics(t, func() { cred0.PublicKey() })
+	require.Panics(t, func() { cred0.Scheme() })
 
 	_, err := cred0.MarshalTLS()
-	assertError(t, err, "Marshal for bad credential")
+	require.Error(t, err)
 }

crypto_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/bifurcation/mint/syntax"
+	"github.com/stretchr/testify/require"
 )
 
 var supportedSuites = []CipherSuite{
@@ -36,9 +37,7 @@ func TestDigest(t *testing.T) {
 		}
 
 		d := suite.digest(in)
-		if !bytes.Equal(d, out) {
-			t.Fatalf("Incorrect digest: %x != %x", d, out)
-		}
+		require.Equal(t, d, out)
 	}
 }
 
@@ -75,24 +74,16 @@ func TestEncryptDecrypt(t *testing.T) {
 			}
 
 			aead, err := suite.newAEAD(key)
-			if err != nil {
-				t.Fatalf("Error creating AEAD: %v", err)
-			}
+			require.Nil(t, err)
 
 			// Test encryption
 			encrypted := aead.Seal(nil, nonce, pt, aad)
-			if !bytes.Equal(ct, encrypted) {
-				t.Fatalf("Incorrect encryption: %x != %x", ct, encrypted)
-			}
+			require.Equal(t, ct, encrypted)
 
 			// Test decryption
 			decrypted, err := aead.Open(nil, nonce, ct, aad)
-			if err != nil {
-				t.Fatalf("Error in decryption: %v", err)
-			}
-			if !bytes.Equal(pt, decrypted) {
-				t.Fatalf("Incorrect decryption: %x != %x", pt, decrypted)
-			}
+			require.Nil(t, err)
+			require.Equal(t, pt, decrypted)
 		}
 	}
 
@@ -109,17 +100,17 @@ func TestHPKE(t *testing.T) {
 	encryptDecrypt := func(suite CipherSuite) func(t *testing.T) {
 		return func(t *testing.T) {
 			priv, err := suite.hpke().Generate()
-			assertNotError(t, err, "Error generating HPKE key")
+			require.Nil(t, err)
 
 			priv, err = suite.hpke().Derive(seed)
-			assertNotError(t, err, "Error deriving HPKE key")
+			require.Nil(t, err)
 
 			encrypted, err := suite.hpke().Encrypt(priv.PublicKey, aad, original)
-			assertNotError(t, err, "Error in HPKE encryption")
+			require.Nil(t, err)
 
 			decrypted, err := suite.hpke().Decrypt(priv, aad, encrypted)
-			assertNotError(t, err, "Error in HPKE decryption")
-			assertByteEquals(t, original, decrypted)
+			require.Nil(t, err)
+			require.Equal(t, original, decrypted)
 		}
 	}
 
@@ -135,16 +126,16 @@ func TestSignVerify(t *testing.T) {
 	signVerify := func(scheme SignatureScheme) func(t *testing.T) {
 		return func(t *testing.T) {
 			priv, err := scheme.Generate()
-			assertNotError(t, err, "Error generating signing key")
+			require.Nil(t, err)
 
 			priv, err = scheme.Derive(seed)
-			assertNotError(t, err, "Error generating signing key")
+			require.Nil(t, err)
 
 			signature, err := scheme.Sign(&priv, message)
-			assertNotError(t, err, "Error signing")
+			require.Nil(t, err)
 
 			verified := scheme.Verify(&priv.PublicKey, message, signature)
-			assertTrue(t, verified, "Signature failed to verify")
+			require.True(t, verified)
 		}
 	}
 
@@ -194,32 +185,32 @@ func generateCryptoVectors(t *testing.T) []byte {
 
 		priv, err = tc.CipherSuite.hpke().Derive(tv.DeriveKeyPairSeed)
 		tc.DeriveKeyPairPub = priv.PublicKey
-		assertNotError(t, err, "Error deriving HPKE key pair")
+		require.Nil(t, err)
 
 		tc.HPKEOut, err = tc.CipherSuite.hpke().Encrypt(tc.DeriveKeyPairPub, tv.HPKEAAD, tv.HPKEPlaintext)
-		assertNotError(t, err, "Error in HPKE encryption")
+		require.Nil(t, err)
 	}
 
 	vec, err := syntax.Marshal(tv)
-	assertNotError(t, err, "Error marshaling test vectors")
+	require.Nil(t, err)
 	return vec
 }
 
 func verifyCryptoVectors(t *testing.T, data []byte) {
 	var tv CryptoTestVectors
 	_, err := syntax.Unmarshal(data, &tv)
-	assertNotError(t, err, "Malformed crypto test vectors")
+	require.Nil(t, err)
 
 	for _, tc := range tv.Cases {
 		hkdfExtractOut := tc.CipherSuite.hkdfExtract(tv.HKDFExtractSalt, tv.HKDFExtractIKM)
-		assertByteEquals(t, hkdfExtractOut, tc.HKDFExtractOut)
+		require.Equal(t, hkdfExtractOut, tc.HKDFExtractOut)
 
 		priv, err = tc.CipherSuite.hpke().Derive(tv.DeriveKeyPairSeed)
-		assertNotError(t, err, "Error deriving HPKE key pair")
-		assertByteEquals(t, priv.PublicKey.Data, tc.DeriveKeyPairPub.Data)
+		require.Nil(t, err)
+		require.Equal(t, priv.PublicKey.Data, tc.DeriveKeyPairPub.Data)
 
 		plaintext, err := tc.CipherSuite.hpke().Decrypt(priv, tv.HPKEAAD, tc.HPKEOut)
-		assertNotError(t, err, "Error in HPKE decryption")
-		assertDeepEquals(t, plaintext, tv.HPKEPlaintext)
+		require.Nil(t, err)
+		require.Equal(t, plaintext, tv.HPKEPlaintext)
 	}
 }