literal: fix flacky test

also: make tests less noisy everywhere

pkg/policy/literal/literal.go

@@ -4,6 +4,7 @@ package literal
 import (
 	"fmt"
 	"reflect"
+	"sort"
 
 	"github.com/ipfs/go-cid"
 	"github.com/ipld/go-ipld-prime"
@@ -33,8 +34,14 @@ func Null() ipld.Node {
 // Map creates an IPLD node from a map[string]any
 func Map[T any](m map[string]T) (ipld.Node, error) {
 	return qp.BuildMap(basicnode.Prototype.Any, int64(len(m)), func(ma datamodel.MapAssembler) {
-		for k, v := range m {
-			qp.MapEntry(ma, k, anyAssemble(v))
+		// deterministic iteration
+		keys := make([]string, 0, len(m))
+		for key := range m {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			qp.MapEntry(ma, key, anyAssemble(m[key]))
 		}
 	})
 }
@@ -90,10 +97,14 @@ func anyAssemble(val any) qp.Assemble {
 		if rt.Key().Kind() != reflect.String {
 			break
 		}
-		it := rv.MapRange()
+		// deterministic iteration
+		keys := rv.MapKeys()
+		sort.Slice(keys, func(i, j int) bool {
+			return keys[i].String() < keys[j].String()
+		})
 		return qp.Map(int64(rv.Len()), func(ma datamodel.MapAssembler) {
-			for it.Next() {
-				qp.MapEntry(ma, it.Key().String(), anyAssemble(it.Value()))
+			for _, key := range keys {
+				qp.MapEntry(ma, key.String(), anyAssemble(rv.MapIndex(key)))
 			}
 		})
 	case reflect.Bool:

pkg/policy/match.go

@@ -9,9 +9,6 @@ import (
 	"github.com/ipld/go-ipld-prime/must"
 )
 
-// MatchTrace, if set, will print tracing statements to stdout of the policy matching resolution.
-var MatchTrace = false
-
 // Match determines if the IPLD node satisfies the policy.
 func (p Policy) Match(node datamodel.Node) bool {
 	for _, stmt := range p {
@@ -62,7 +59,7 @@ const (
 // - matchResultNoData: if the selector didn't match the expected data.
 // For matchResultTrue and matchResultNoData, the leaf-most (innermost) statement failing to be true is returned,
 // as well as the corresponding root-most encompassing statement.
-func matchStatement(cur Statement, node ipld.Node) (output matchResult, leafMost Statement) {
+func matchStatement(cur Statement, node ipld.Node) (_ matchResult, leafMost Statement) {
 	var boolToRes = func(v bool) (matchResult, Statement) {
 		if v {
 			return matchResultTrue, nil
@@ -70,11 +67,6 @@ func matchStatement(cur Statement, node ipld.Node) (output matchResult, leafMost
 			return matchResultFalse, cur
 		}
 	}
-	if MatchTrace {
-		defer func() {
-			fmt.Printf("match %v --> %v\n", cur, matchResToStr(output))
-		}()
-	}
 
 	switch cur.Kind() {
 	case KindEqual:
@@ -282,18 +274,3 @@ func gt(order int) bool  { return order == 1 }
 func gte(order int) bool { return order == 0 || order == 1 }
 func lt(order int) bool  { return order == -1 }
 func lte(order int) bool { return order == 0 || order == -1 }
-
-func matchResToStr(res matchResult) string {
-	switch res {
-	case matchResultTrue:
-		return "True"
-	case matchResultFalse:
-		return "False"
-	case matchResultNoData:
-		return "NoData"
-	case matchResultOptionalNoData:
-		return "OptionalNoData"
-	default:
-		panic("invalid matchResult")
-	}
-}

pkg/policy/selector/parsing_test.go

@@ -1,7 +1,6 @@
 package selector
 
 import (
-	"fmt"
 	"math"
 	"testing"
 
@@ -354,7 +353,6 @@ func TestParse(t *testing.T) {
 		str := `.foo.["bar"].[138]?.baz[1:]`
 		sel, err := Parse(str)
 		require.NoError(t, err)
-		printSegments(sel)
 		require.Equal(t, str, sel.String())
 		require.Equal(t, 7, len(sel))
 		require.False(t, sel[0].Identity())
@@ -404,13 +402,11 @@ func TestParse(t *testing.T) {
 	t.Run("non dotted", func(t *testing.T) {
 		_, err := Parse("foo")
 		require.NotNil(t, err)
-		fmt.Println(err)
 	})
 
 	t.Run("non quoted", func(t *testing.T) {
 		_, err := Parse(".[foo]")
 		require.NotNil(t, err)
-		fmt.Println(err)
 	})
 
 	t.Run("slice with negative start and positive end", func(t *testing.T) {
@@ -554,9 +550,3 @@ func TestParse(t *testing.T) {
 		require.Error(t, err)
 	})
 }
-
-func printSegments(s Selector) {
-	for i, seg := range s {
-		fmt.Printf("%d: %s\n", i, seg.String())
-	}
-}

pkg/policy/selector/selector_test.go

@@ -2,7 +2,6 @@ package selector
 
 import (
 	"errors"
-	"fmt"
 	"strings"
 	"testing"
 
@@ -13,7 +12,6 @@ import (
 	"github.com/ipld/go-ipld-prime/must"
 	basicnode "github.com/ipld/go-ipld-prime/node/basic"
 	"github.com/ipld/go-ipld-prime/node/bindnode"
-	"github.com/ipld/go-ipld-prime/printer"
 	"github.com/stretchr/testify/require"
 )
 
@@ -87,8 +85,6 @@ func TestSelect(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, res)
 
-		fmt.Println(printer.Sprint(res))
-
 		age := must.Int(must.Node(res.LookupByString("age")))
 		require.Equal(t, int64(alice.Age), age)
 	})
@@ -101,8 +97,6 @@ func TestSelect(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, res)
 
-		fmt.Println(printer.Sprint(res))
-
 		name := must.String(res)
 		require.Equal(t, alice.Name.First, name)
 
@@ -110,8 +104,6 @@ func TestSelect(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, res)
 
-		fmt.Println(printer.Sprint(res))
-
 		name = must.String(res)
 		require.Equal(t, bob.Name.First, name)
 	})
@@ -124,8 +116,6 @@ func TestSelect(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, res)
 
-		fmt.Println(printer.Sprint(res))
-
 		name := must.String(res)
 		require.Equal(t, *alice.Name.Middle, name)
 
@@ -142,8 +132,6 @@ func TestSelect(t *testing.T) {
 		require.Error(t, err)
 		require.Empty(t, res)
 
-		fmt.Println(err)
-
 		require.ErrorAs(t, err, &resolutionerr{}, "error should be a resolution error")
 	})
 
@@ -164,8 +152,6 @@ func TestSelect(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, res)
 
-		fmt.Println(printer.Sprint(res))
-
 		iname := must.String(must.Node(must.Node(res.LookupByIndex(0)).LookupByString("name")))
 		require.Equal(t, alice.Interests[0].Name, iname)
 

pkg/policy/selector/supported_test.go

@@ -1,15 +1,12 @@
 package selector_test
 
 import (
-	"bytes"
 	"strings"
 	"testing"
 
 	"github.com/ipld/go-ipld-prime"
 	"github.com/ipld/go-ipld-prime/codec/dagjson"
-	"github.com/ipld/go-ipld-prime/datamodel"
 	basicnode "github.com/ipld/go-ipld-prime/node/basic"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/ucan-wg/go-ucan/pkg/policy/selector"
@@ -55,7 +52,7 @@ func TestSupportedForms(t *testing.T) {
 			require.NotNil(t, res)
 
 			exp := makeNode(t, tc.Output)
-			equalIPLD(t, exp, res)
+			require.True(t, ipld.DeepEqual(exp, res))
 		})
 	}
 
@@ -106,23 +103,6 @@ func TestSupportedForms(t *testing.T) {
 	}
 }
 
-func equalIPLD(t *testing.T, expected datamodel.Node, actual datamodel.Node) bool {
-	t.Helper()
-
-	exp, act := &bytes.Buffer{}, &bytes.Buffer{}
-	if err := dagjson.Encode(expected, exp); err != nil {
-		return assert.Fail(t, "Failed to encode json for expected IPLD node")
-	}
-
-	if err := dagjson.Encode(actual, act); err != nil {
-		return assert.Fail(t, "Failed to encode JSON for actual IPLD node")
-	}
-
-	require.JSONEq(t, exp.String(), act.String())
-
-	return true
-}
-
 func makeNode(t *testing.T, dagJsonInput string) ipld.Node {
 	t.Helper()
 

token/delegation/delegation_test.go

@@ -100,8 +100,6 @@ func TestConstructors(t *testing.T) {
 		data, err := tkn.ToDagJson(privKey)
 		require.NoError(t, err)
 
-		t.Log(string(data))
-
 		golden.Assert(t, string(data), "new.dagjson")
 	})
 
@@ -119,8 +117,6 @@ func TestConstructors(t *testing.T) {
 		data, err := tkn.ToDagJson(privKey)
 		require.NoError(t, err)
 
-		t.Log(string(data))
-
 		golden.Assert(t, string(data), "root.dagjson")
 	})
 }

token/delegation/schema_test.go

@@ -3,7 +3,6 @@ package delegation_test
 import (
 	"bytes"
 	_ "embed"
-	"fmt"
 	"testing"
 
 	"github.com/ipld/go-ipld-prime"
@@ -36,18 +35,13 @@ func TestSchemaRoundTrip(t *testing.T) {
 		cborBytes, id, err := p1.ToSealed(privKey)
 		require.NoError(t, err)
 		assert.Equal(t, newCID, envelope.CIDToBase58BTC(id))
-		fmt.Println("cborBytes length", len(cborBytes))
-		fmt.Println("cbor", string(cborBytes))
 
 		p2, c2, err := delegation.FromSealed(cborBytes)
 		require.NoError(t, err)
 		assert.Equal(t, id, c2)
-		fmt.Println("read Cbor", p2)
 
 		readJson, err := p2.ToDagJson(privKey)
 		require.NoError(t, err)
-		fmt.Println("readJson length", len(readJson))
-		fmt.Println("json: ", string(readJson))
 
 		assert.JSONEq(t, string(delegationJson), string(readJson))
 	})
@@ -65,7 +59,6 @@ func TestSchemaRoundTrip(t *testing.T) {
 
 		cborBytes := &bytes.Buffer{}
 		id, err := p1.ToSealedWriter(cborBytes, privKey)
-		t.Log(len(id.Bytes()), id.Bytes())
 		require.NoError(t, err)
 		assert.Equal(t, newCID, envelope.CIDToBase58BTC(id))