proof: more tests

Signed-off-by: Ignacio Hagopian <jsign.uy@gmail.com>

Author: jsign

proof.go

@@ -56,10 +56,10 @@ func ValidateProof(ctx context.Context, root cid.Cid, offset uint64, proof []byt
 	// is missing.
 	regenProof, err := CreateProof(ctx, root, offset, dserv)
 	if err != nil {
-		return false, fmt.Errorf("regenerating proof to validate: %s", err)
+		return false, nil
 	}
 
-	return !bytes.Equal(proof, regenProof), nil
+	return bytes.Equal(proof, regenProof), nil
 }
 
 // CreateProof creates a proof for a Cid at a specified file offset.
@@ -80,6 +80,7 @@ func CreateProof(ctx context.Context, root cid.Cid, offset uint64, dserv ipld.DA
 			}
 			proofNodes = append(proofNodes, cn)
 
+			// REMOVE THIS?
 			if next == nil {
 				fsNode, err := unixfs.ExtractFSNode(n)
 				if err != nil {

proof_test.go

@@ -3,6 +3,7 @@ package unixfsproof
 import (
 	"bytes"
 	"context"
+	"fmt"
 	"io"
 	"math/rand"
 	"testing"
@@ -14,14 +15,14 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestMakeProof(t *testing.T) {
-	dserv := testu.GetDAGServ()
+func TestProofVerify(t *testing.T) {
+	t.Parallel()
 
+	dserv := testu.GetDAGServ()
 	r := rand.New(rand.NewSource(22))
 	data := make([]byte, 100000)
 	_, err := io.ReadFull(r, data)
 	require.NoError(t, err)
-
 	in := bytes.NewReader(data)
 	opts := testu.UseCidV1
 	dbp := h.DagBuilderParams{
@@ -30,19 +31,51 @@ func TestMakeProof(t *testing.T) {
 		CidBuilder: opts.Prefix,
 		RawLeaves:  opts.RawLeavesUsed,
 	}
-
-	db, err := dbp.New(chunker.NewSizeSplitter(in, 256))
+	chunkSize := int64(256)
+	db, err := dbp.New(chunker.NewSizeSplitter(in, chunkSize))
 	require.NoError(t, err)
 	node, err := balanced.Layout(db)
 	require.NoError(t, err)
 
-	offset := uint64(50000)
-	ctx, cls := context.WithCancel(context.Background())
-	defer cls()
-	proof, err := CreateProof(ctx, node.Cid(), offset, dserv)
-	require.NoError(t, err)
+	tests := []struct {
+		proofOffset uint64
+		verifOffset uint64
+		ok          bool
+	}{
+		// Correct proofs.
+		{proofOffset: 40, verifOffset: 40, ok: true},
+		{proofOffset: 500, verifOffset: 500, ok: true},
+		{proofOffset: 6000, verifOffset: 6000, ok: true},
+		{proofOffset: 70000, verifOffset: 70000, ok: true},
 
-	ok, err := ValidateProof(ctx, node.Cid(), offset, proof)
-	require.NoError(t, err)
-	require.True(t, ok)
+		// Correct proof due to being in same block
+		{proofOffset: 40, verifOffset: 41, ok: true},
+		{proofOffset: 41, verifOffset: 40, ok: true},
+
+		// Indirectly correct proofs; this should work unless we change
+		// the verification to not allow unvisited blocks; not clear if that's
+		// entirely useful.
+		{proofOffset: 868, verifOffset: 1124, ok: true},
+
+		// Definitely wrong proofs.
+		{proofOffset: 40, verifOffset: 50000, ok: false},
+		{proofOffset: 70000, verifOffset: 10, ok: false},
+	}
+
+	for _, test := range tests {
+		test := test
+		tname := fmt.Sprintf("%d %d", test.proofOffset, test.verifOffset)
+
+		t.Run(tname, func(t *testing.T) {
+			ctx, cls := context.WithCancel(context.Background())
+			defer cls()
+			proof, err := CreateProof(ctx, node.Cid(), test.proofOffset, dserv)
+			require.NoError(t, err)
+
+			ok, err := ValidateProof(ctx, node.Cid(), test.verifOffset, proof)
+			require.NoError(t, err)
+
+			require.Equal(t, test.ok, ok)
+		})
+	}
 }