From 37712da66f7bb2acafd19172cd33d34227ad8b44 Mon Sep 17 00:00:00 2001
From: Alan Shaw <alan.shaw@protocol.ai>
Date: Wed, 21 Aug 2024 08:48:39 +0200
Subject: [PATCH] refactor: reorg tests

---
 match_test.go | 496 +++++++++++++++++++++++++-------------------------
 1 file changed, 251 insertions(+), 245 deletions(-)

diff --git a/match_test.go b/match_test.go
index 10049a9..e7546a5 100644
--- a/match_test.go
+++ b/match_test.go
@@ -15,204 +15,208 @@ import (
 )
 
 func TestMatch(t *testing.T) {
-	t.Run("equality string", func(t *testing.T) {
-		np := basicnode.Prototype.String
-		nb := np.NewBuilder()
-		nb.AssignString("test")
-		nd := nb.Build()
+	t.Run("equality", func(t *testing.T) {
+		t.Run("string", func(t *testing.T) {
+			np := basicnode.Prototype.String
+			nb := np.NewBuilder()
+			nb.AssignString("test")
+			nd := nb.Build()
 
-		pol := Policy{Equal(selector.MustParse("."), literal.String("test"))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
+			pol := Policy{Equal(selector.MustParse("."), literal.String("test"))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
 
-		pol = Policy{Equal(selector.MustParse("."), literal.String("test2"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+			pol = Policy{Equal(selector.MustParse("."), literal.String("test2"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
 
-		pol = Policy{Equal(selector.MustParse("."), literal.Int(138))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+			pol = Policy{Equal(selector.MustParse("."), literal.Int(138))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
+
+		t.Run("int", func(t *testing.T) {
+			np := basicnode.Prototype.Int
+			nb := np.NewBuilder()
+			nb.AssignInt(138)
+			nd := nb.Build()
+
+			pol := Policy{Equal(selector.MustParse("."), literal.Int(138))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.Int(1138))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.String("138"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
+
+		t.Run("float", func(t *testing.T) {
+			np := basicnode.Prototype.Float
+			nb := np.NewBuilder()
+			nb.AssignFloat(1.138)
+			nd := nb.Build()
+
+			pol := Policy{Equal(selector.MustParse("."), literal.Float(1.138))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.Float(11.38))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.String("138"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
+
+		t.Run("IPLD Link", func(t *testing.T) {
+			l0 := cidlink.Link{Cid: cid.MustParse("bafybeif4owy5gno5lwnixqm52rwqfodklf76hsetxdhffuxnplvijskzqq")}
+			l1 := cidlink.Link{Cid: cid.MustParse("bafkreifau35r7vi37tvbvfy3hdwvgb4tlflqf7zcdzeujqcjk3rsphiwte")}
+
+			np := basicnode.Prototype.Link
+			nb := np.NewBuilder()
+			nb.AssignLink(l0)
+			nd := nb.Build()
+
+			pol := Policy{Equal(selector.MustParse("."), literal.Link(l0))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.Link(l1))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+
+			pol = Policy{Equal(selector.MustParse("."), literal.String("bafybeif4owy5gno5lwnixqm52rwqfodklf76hsetxdhffuxnplvijskzqq"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
+
+		t.Run("string in map", func(t *testing.T) {
+			np := basicnode.Prototype.Map
+			nb := np.NewBuilder()
+			ma, _ := nb.BeginMap(1)
+			ma.AssembleKey().AssignString("foo")
+			ma.AssembleValue().AssignString("bar")
+			ma.Finish()
+			nd := nb.Build()
+
+			pol := Policy{Equal(selector.MustParse(".foo"), literal.String("bar"))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse(".[\"foo\"]"), literal.String("bar"))}
+			ok = Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse(".foo"), literal.String("baz"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+
+			pol = Policy{Equal(selector.MustParse(".foobar"), literal.String("bar"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
+
+		t.Run("string in list", func(t *testing.T) {
+			np := basicnode.Prototype.List
+			nb := np.NewBuilder()
+			la, _ := nb.BeginList(1)
+			la.AssembleValue().AssignString("foo")
+			la.Finish()
+			nd := nb.Build()
+
+			pol := Policy{Equal(selector.MustParse(".[0]"), literal.String("foo"))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{Equal(selector.MustParse(".[1]"), literal.String("foo"))}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
 	})
 
-	t.Run("equality int", func(t *testing.T) {
-		np := basicnode.Prototype.Int
-		nb := np.NewBuilder()
-		nb.AssignInt(138)
-		nd := nb.Build()
+	t.Run("inequality", func(t *testing.T) {
+		t.Run("gt int", func(t *testing.T) {
+			np := basicnode.Prototype.Int
+			nb := np.NewBuilder()
+			nb.AssignInt(138)
+			nd := nb.Build()
 
-		pol := Policy{Equal(selector.MustParse("."), literal.Int(138))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
+			pol := Policy{GreaterThan(selector.MustParse("."), literal.Int(1))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+		})
 
-		pol = Policy{Equal(selector.MustParse("."), literal.Int(1138))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+		t.Run("gte int", func(t *testing.T) {
+			np := basicnode.Prototype.Int
+			nb := np.NewBuilder()
+			nb.AssignInt(138)
+			nd := nb.Build()
 
-		pol = Policy{Equal(selector.MustParse("."), literal.String("138"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
+			pol := Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Int(1))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
 
-	t.Run("equality float", func(t *testing.T) {
-		np := basicnode.Prototype.Float
-		nb := np.NewBuilder()
-		nb.AssignFloat(1.138)
-		nd := nb.Build()
+			pol = Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Int(138))}
+			ok = Match(pol, nd)
+			require.True(t, ok)
+		})
 
-		pol := Policy{Equal(selector.MustParse("."), literal.Float(1.138))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
+		t.Run("gt float", func(t *testing.T) {
+			np := basicnode.Prototype.Float
+			nb := np.NewBuilder()
+			nb.AssignFloat(1.38)
+			nd := nb.Build()
 
-		pol = Policy{Equal(selector.MustParse("."), literal.Float(11.38))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+			pol := Policy{GreaterThan(selector.MustParse("."), literal.Float(1))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+		})
 
-		pol = Policy{Equal(selector.MustParse("."), literal.String("138"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
+		t.Run("gte float", func(t *testing.T) {
+			np := basicnode.Prototype.Float
+			nb := np.NewBuilder()
+			nb.AssignFloat(1.38)
+			nd := nb.Build()
 
-	t.Run("equality IPLD Link", func(t *testing.T) {
-		l0 := cidlink.Link{Cid: cid.MustParse("bafybeif4owy5gno5lwnixqm52rwqfodklf76hsetxdhffuxnplvijskzqq")}
-		l1 := cidlink.Link{Cid: cid.MustParse("bafkreifau35r7vi37tvbvfy3hdwvgb4tlflqf7zcdzeujqcjk3rsphiwte")}
+			pol := Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Float(1))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
 
-		np := basicnode.Prototype.Link
-		nb := np.NewBuilder()
-		nb.AssignLink(l0)
-		nd := nb.Build()
+			pol = Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Float(1.38))}
+			ok = Match(pol, nd)
+			require.True(t, ok)
+		})
 
-		pol := Policy{Equal(selector.MustParse("."), literal.Link(l0))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
+		t.Run("lt int", func(t *testing.T) {
+			np := basicnode.Prototype.Int
+			nb := np.NewBuilder()
+			nb.AssignInt(138)
+			nd := nb.Build()
 
-		pol = Policy{Equal(selector.MustParse("."), literal.Link(l1))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+			pol := Policy{LessThan(selector.MustParse("."), literal.Int(1138))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+		})
 
-		pol = Policy{Equal(selector.MustParse("."), literal.String("bafybeif4owy5gno5lwnixqm52rwqfodklf76hsetxdhffuxnplvijskzqq"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
+		t.Run("lte int", func(t *testing.T) {
+			np := basicnode.Prototype.Int
+			nb := np.NewBuilder()
+			nb.AssignInt(138)
+			nd := nb.Build()
 
-	t.Run("equality string in map", func(t *testing.T) {
-		np := basicnode.Prototype.Map
-		nb := np.NewBuilder()
-		ma, _ := nb.BeginMap(1)
-		ma.AssembleKey().AssignString("foo")
-		ma.AssembleValue().AssignString("bar")
-		ma.Finish()
-		nd := nb.Build()
+			pol := Policy{LessThanOrEqual(selector.MustParse("."), literal.Int(1138))}
+			ok := Match(pol, nd)
+			require.True(t, ok)
 
-		pol := Policy{Equal(selector.MustParse(".foo"), literal.String("bar"))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{Equal(selector.MustParse(".[\"foo\"]"), literal.String("bar"))}
-		ok = Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{Equal(selector.MustParse(".foo"), literal.String("baz"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-
-		pol = Policy{Equal(selector.MustParse(".foobar"), literal.String("bar"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
-
-	t.Run("equality string in list", func(t *testing.T) {
-		np := basicnode.Prototype.List
-		nb := np.NewBuilder()
-		la, _ := nb.BeginList(1)
-		la.AssembleValue().AssignString("foo")
-		la.Finish()
-		nd := nb.Build()
-
-		pol := Policy{Equal(selector.MustParse(".[0]"), literal.String("foo"))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{Equal(selector.MustParse(".[1]"), literal.String("foo"))}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
-
-	t.Run("inequality gt int", func(t *testing.T) {
-		np := basicnode.Prototype.Int
-		nb := np.NewBuilder()
-		nb.AssignInt(138)
-		nd := nb.Build()
-
-		pol := Policy{GreaterThan(selector.MustParse("."), literal.Int(1))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-	})
-
-	t.Run("inequality gte int", func(t *testing.T) {
-		np := basicnode.Prototype.Int
-		nb := np.NewBuilder()
-		nb.AssignInt(138)
-		nd := nb.Build()
-
-		pol := Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Int(1))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Int(138))}
-		ok = Match(pol, nd)
-		require.True(t, ok)
-	})
-
-	t.Run("inequality gt float", func(t *testing.T) {
-		np := basicnode.Prototype.Float
-		nb := np.NewBuilder()
-		nb.AssignFloat(1.38)
-		nd := nb.Build()
-
-		pol := Policy{GreaterThan(selector.MustParse("."), literal.Float(1))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-	})
-
-	t.Run("inequality gte float", func(t *testing.T) {
-		np := basicnode.Prototype.Float
-		nb := np.NewBuilder()
-		nb.AssignFloat(1.38)
-		nd := nb.Build()
-
-		pol := Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Float(1))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{GreaterThanOrEqual(selector.MustParse("."), literal.Float(1.38))}
-		ok = Match(pol, nd)
-		require.True(t, ok)
-	})
-
-	t.Run("inequality lt int", func(t *testing.T) {
-		np := basicnode.Prototype.Int
-		nb := np.NewBuilder()
-		nb.AssignInt(138)
-		nd := nb.Build()
-
-		pol := Policy{LessThan(selector.MustParse("."), literal.Int(1138))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-	})
-
-	t.Run("inequality lte int", func(t *testing.T) {
-		np := basicnode.Prototype.Int
-		nb := np.NewBuilder()
-		nb.AssignInt(138)
-		nd := nb.Build()
-
-		pol := Policy{LessThanOrEqual(selector.MustParse("."), literal.Int(1138))}
-		ok := Match(pol, nd)
-		require.True(t, ok)
-
-		pol = Policy{LessThanOrEqual(selector.MustParse("."), literal.Int(138))}
-		ok = Match(pol, nd)
-		require.True(t, ok)
+			pol = Policy{LessThanOrEqual(selector.MustParse("."), literal.Int(138))}
+			ok = Match(pol, nd)
+			require.True(t, ok)
+		})
 	})
 
 	t.Run("negation", func(t *testing.T) {
@@ -333,76 +337,78 @@ func TestMatch(t *testing.T) {
 		}
 	})
 
-	buildValueNode := func(v int64) ipld.Node {
-		np := basicnode.Prototype.Map
-		nb := np.NewBuilder()
-		ma, _ := nb.BeginMap(1)
-		ma.AssembleKey().AssignString("value")
-		ma.AssembleValue().AssignInt(v)
-		ma.Finish()
-		return nb.Build()
-	}
-
-	t.Run("quantification all", func(t *testing.T) {
-		np := basicnode.Prototype.List
-		nb := np.NewBuilder()
-		la, _ := nb.BeginList(5)
-		la.AssembleValue().AssignNode(buildValueNode(5))
-		la.AssembleValue().AssignNode(buildValueNode(10))
-		la.AssembleValue().AssignNode(buildValueNode(20))
-		la.AssembleValue().AssignNode(buildValueNode(50))
-		la.AssembleValue().AssignNode(buildValueNode(100))
-		la.Finish()
-		nd := nb.Build()
-
-		pol := Policy{
-			All(
-				selector.MustParse(".[]"),
-				GreaterThan(selector.MustParse(".value"), literal.Int(2)),
-			),
+	t.Run("quantification", func(t *testing.T) {
+		buildValueNode := func(v int64) ipld.Node {
+			np := basicnode.Prototype.Map
+			nb := np.NewBuilder()
+			ma, _ := nb.BeginMap(1)
+			ma.AssembleKey().AssignString("value")
+			ma.AssembleValue().AssignInt(v)
+			ma.Finish()
+			return nb.Build()
 		}
-		ok := Match(pol, nd)
-		require.True(t, ok)
 
-		pol = Policy{
-			All(
-				selector.MustParse(".[]"),
-				GreaterThan(selector.MustParse(".value"), literal.Int(20)),
-			),
-		}
-		ok = Match(pol, nd)
-		require.False(t, ok)
-	})
+		t.Run("all", func(t *testing.T) {
+			np := basicnode.Prototype.List
+			nb := np.NewBuilder()
+			la, _ := nb.BeginList(5)
+			la.AssembleValue().AssignNode(buildValueNode(5))
+			la.AssembleValue().AssignNode(buildValueNode(10))
+			la.AssembleValue().AssignNode(buildValueNode(20))
+			la.AssembleValue().AssignNode(buildValueNode(50))
+			la.AssembleValue().AssignNode(buildValueNode(100))
+			la.Finish()
+			nd := nb.Build()
 
-	t.Run("quantification any", func(t *testing.T) {
-		np := basicnode.Prototype.List
-		nb := np.NewBuilder()
-		la, _ := nb.BeginList(5)
-		la.AssembleValue().AssignNode(buildValueNode(5))
-		la.AssembleValue().AssignNode(buildValueNode(10))
-		la.AssembleValue().AssignNode(buildValueNode(20))
-		la.AssembleValue().AssignNode(buildValueNode(50))
-		la.AssembleValue().AssignNode(buildValueNode(100))
-		la.Finish()
-		nd := nb.Build()
+			pol := Policy{
+				All(
+					selector.MustParse(".[]"),
+					GreaterThan(selector.MustParse(".value"), literal.Int(2)),
+				),
+			}
+			ok := Match(pol, nd)
+			require.True(t, ok)
 
-		pol := Policy{
-			Any(
-				selector.MustParse(".[]"),
-				GreaterThan(selector.MustParse(".value"), literal.Int(10)),
-				LessThan(selector.MustParse(".value"), literal.Int(50)),
-			),
-		}
-		ok := Match(pol, nd)
-		require.True(t, ok)
+			pol = Policy{
+				All(
+					selector.MustParse(".[]"),
+					GreaterThan(selector.MustParse(".value"), literal.Int(20)),
+				),
+			}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
 
-		pol = Policy{
-			Any(
-				selector.MustParse(".[]"),
-				GreaterThan(selector.MustParse(".value"), literal.Int(100)),
-			),
-		}
-		ok = Match(pol, nd)
-		require.False(t, ok)
+		t.Run("any", func(t *testing.T) {
+			np := basicnode.Prototype.List
+			nb := np.NewBuilder()
+			la, _ := nb.BeginList(5)
+			la.AssembleValue().AssignNode(buildValueNode(5))
+			la.AssembleValue().AssignNode(buildValueNode(10))
+			la.AssembleValue().AssignNode(buildValueNode(20))
+			la.AssembleValue().AssignNode(buildValueNode(50))
+			la.AssembleValue().AssignNode(buildValueNode(100))
+			la.Finish()
+			nd := nb.Build()
+
+			pol := Policy{
+				Any(
+					selector.MustParse(".[]"),
+					GreaterThan(selector.MustParse(".value"), literal.Int(10)),
+					LessThan(selector.MustParse(".value"), literal.Int(50)),
+				),
+			}
+			ok := Match(pol, nd)
+			require.True(t, ok)
+
+			pol = Policy{
+				Any(
+					selector.MustParse(".[]"),
+					GreaterThan(selector.MustParse(".value"), literal.Int(100)),
+				),
+			}
+			ok = Match(pol, nd)
+			require.False(t, ok)
+		})
 	})
 }