Add tests for existence proof

Author: ethanfrey

go/ops.go

@@ -9,29 +9,20 @@ import (
 	fmt "fmt"
 )
 
-// Calculate determines the root hash that matches the given proof.
-// You must validate the result is what you have in a header.
-// Returns error if the calculations cannot be performed.
-func (p *ExistanceProof) Calculate() ([]byte, error) {
-	if len(p.Steps) == 0 {
-		return nil, fmt.Errorf("Existence Proof needs at least one step")
-	}
-
-	first, rem := p.Steps[0], p.Steps[1:]
-	// first step takes the key and value as input
-	res, err := first.Apply(p.Key, p.Value)
-	if err != nil {
-		return nil, err
+func WrapLeaf(leaf *LeafOp) *ProofOp {
+	return &ProofOp{
+		Op: &ProofOp_Leaf{
+			Leaf: leaf,
+		},
 	}
+}
 
-	// the rest just take the output of the last step (reducing it)
-	for _, step := range rem {
-		res, err = step.Apply(res)
-		if err != nil {
-			return nil, err
-		}
+func WrapInner(inner *InnerOp) *ProofOp {
+	return &ProofOp{
+		Op: &ProofOp_Inner{
+			Inner: inner,
+		},
 	}
-	return res, nil
 }
 
 func (op *ProofOp) Apply(args ...[]byte) ([]byte, error) {

go/ops_test.go

@@ -173,7 +173,6 @@ func TestInnerOp(t *testing.T) {
 			}
 		})
 	}
-
 }
 
 func fromHex(data string) []byte {

go/proof.go

@@ -0,0 +1,28 @@
+package proofs
+
+import fmt "fmt"
+
+// Calculate determines the root hash that matches the given proof.
+// You must validate the result is what you have in a header.
+// Returns error if the calculations cannot be performed.
+func (p *ExistenceProof) Calculate() ([]byte, error) {
+	if len(p.Steps) == 0 {
+		return nil, fmt.Errorf("Existence Proof needs at least one step")
+	}
+
+	first, rem := p.Steps[0], p.Steps[1:]
+	// first step takes the key and value as input
+	res, err := first.Apply(p.Key, p.Value)
+	if err != nil {
+		return nil, err
+	}
+
+	// the rest just take the output of the last step (reducing it)
+	for _, step := range rem {
+		res, err = step.Apply(res)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return res, nil
+}

go/proof_test.go

@@ -0,0 +1,105 @@
+package proofs
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestExistenceProof(t *testing.T) {
+	cases := map[string]struct {
+		proof    *ExistenceProof
+		isErr    bool
+		expected []byte
+	}{
+		"must have at least one step": {
+			proof: &ExistenceProof{
+				Key:   []byte("foo"),
+				Value: []byte("bar"),
+			},
+			isErr: true,
+		},
+		// copied from ops_test / TestLeafOp
+		"executes one leaf step": {
+			proof: &ExistenceProof{
+				Key:   []byte("food"),
+				Value: []byte("some longer text"),
+				Steps: []*ProofOp{
+					WrapLeaf(&LeafOp{
+						Hash:   HashOp_SHA256,
+						Length: LengthOp_VAR_PROTO,
+					}),
+				},
+			},
+			expected: fromHex("b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265"),
+		},
+		"cannot execute two leafs": {
+			proof: &ExistenceProof{
+				Key:   []byte("food"),
+				Value: []byte("some longer text"),
+				Steps: []*ProofOp{
+					WrapLeaf(&LeafOp{
+						Hash:   HashOp_SHA256,
+						Length: LengthOp_VAR_PROTO,
+					}),
+					WrapLeaf(&LeafOp{
+						Hash:   HashOp_SHA256,
+						Length: LengthOp_VAR_PROTO,
+					}),
+				},
+			},
+			isErr: true,
+		},
+		"cannot execute inner first": {
+			proof: &ExistenceProof{
+				Key:   []byte("food"),
+				Value: []byte("some longer text"),
+				Steps: []*ProofOp{
+					WrapInner(&InnerOp{
+						Hash:   HashOp_SHA256,
+						Prefix: fromHex("deadbeef00cafe00"),
+					}),
+				},
+			},
+			isErr: true,
+		},
+		"executes lead then inner op": {
+			proof: &ExistenceProof{
+				Key:   []byte("food"),
+				Value: []byte("some longer text"),
+				Steps: []*ProofOp{
+					WrapLeaf(&LeafOp{
+						Hash:   HashOp_SHA256,
+						Length: LengthOp_VAR_PROTO,
+					}),
+					// output: b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265
+					WrapInner(&InnerOp{
+						Hash:   HashOp_SHA256,
+						Prefix: fromHex("deadbeef00cafe00"),
+					}),
+					// echo -n deadbeef00cafe00b68f5d298e915ae1753dd333da1f9cf605411a5f2e12516be6758f365e6db265 | xxd -r -p | sha256sum
+				},
+			},
+			expected: fromHex("836ea236a6902a665c2a004c920364f24cad52ded20b1e4f22c3179bfe25b2a9"),
+		},
+	}
+
+	for name, tc := range cases {
+		t.Run(name, func(t *testing.T) {
+			res, err := tc.proof.Calculate()
+			// short-circuit with error case
+			if tc.isErr {
+				if err == nil {
+					t.Fatal("Expected error, but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(res, tc.expected) {
+				t.Errorf("Bad result: %s vs %s", toHex(res), toHex(tc.expected))
+			}
+		})
+	}
+}

go/proofs.pb.go

@@ -58,7 +58,7 @@ With LengthOp this is tricker but not impossible. Which is why the "leafPrefixEq
 in the ProofSpec is valuable to prevent this mutability. And why all trees should
 length-prefix the data before hashing it.
 */
-message ExistanceProof {
+message ExistenceProof {
     bytes key = 1;
     bytes value = 2;
     repeated ProofOp steps = 3;