[FAB-10272]: Add more test cases to TestSatisfiedBy

Change-Id: I10e49039cfe0fd38087a0ba2fac571f8f5f2d6fb
Signed-off-by: Inbar Badian <Inbar.Badian@ibm.com>

Author: Inbar Badian

common/policies/inquire/inquire_test.go

@@ -17,53 +17,92 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestSatisfiedBy(t *testing.T) {
-	p1, err := cauthdsl.FromString("OR(AND('A.member', 'B.member'), 'C.member', AND('A.member', 'D.member'))")
-	assert.NoError(t, err)
+type testCase struct {
+	name       string
+	policy     string
+	expected   map[string]struct{}
+	principals []*msp.MSPPrincipal
+}
 
+func createPrincipals(orgNames ...string) []*msp.MSPPrincipal {
 	principals := make([]*msp.MSPPrincipal, 0)
-
-	mspId := func(principal *msp.MSPPrincipal) string {
-		role := &msp.MSPRole{}
-		proto.Unmarshal(principal.Principal, role)
-		return role.MspIdentifier
-	}
-
 	appendPrincipal := func(orgName string) {
 		principals = append(principals, &msp.MSPPrincipal{
 			PrincipalClassification: msp.MSPPrincipal_ROLE,
 			Principal:               utils.MarshalOrPanic(&msp.MSPRole{Role: msp.MSPRole_MEMBER, MspIdentifier: orgName})})
 	}
+	for _, org := range orgNames {
+		appendPrincipal(org)
+	}
+	return principals
+}
 
-	appendPrincipal("A")
-	appendPrincipal("B")
-	appendPrincipal("C")
-	appendPrincipal("A")
-	appendPrincipal("D")
+var cases = []testCase{
+	{
+		name:   "orOfAnds",
+		policy: "OR(AND('A.member', 'B.member'), 'C.member', AND('A.member', 'D.member'))",
+		expected: map[string]struct{}{
+			fmt.Sprintf("%v", []string{"A", "B"}): {},
+			fmt.Sprintf("%v", []string{"C"}):      {},
+			fmt.Sprintf("%v", []string{"A", "D"}): {},
+		},
+		principals: createPrincipals("A", "B", "C", "D", "A"),
+	},
+	{
+		name:   "andOfOrs",
+		policy: "AND('A.member', 'C.member', OR('B.member', 'D.member'))",
+		expected: map[string]struct{}{
+			fmt.Sprintf("%v", []string{"A", "C", "B"}): {},
+			fmt.Sprintf("%v", []string{"A", "C", "D"}): {},
+		},
+		principals: createPrincipals("A", "C", "B", "D"),
+	},
+	{
+		name:   "orOfOrs",
+		policy: "OR('A.member', OR('B.member', 'C.member'))",
+		expected: map[string]struct{}{
+			fmt.Sprintf("%v", []string{"A"}): {},
+			fmt.Sprintf("%v", []string{"B"}): {},
+			fmt.Sprintf("%v", []string{"C"}): {},
+		},
+		principals: createPrincipals("A", "B", "C"),
+	},
+	{
+		name:   "andOfAnds",
+		policy: "AND('A.member', AND('B.member', 'C.member'), AND('D.member','A.member'))",
+		expected: map[string]struct{}{
+			fmt.Sprintf("%v", []string{"A", "B", "C", "D", "A"}): {},
+		},
+		principals: createPrincipals("A", "B", "C", "D"),
+	},
+}
 
-	ip := NewInquireableSignaturePolicy(p1)
-	satisfiedBy := ip.SatisfiedBy()
+func TestSatisfiedBy(t *testing.T) {
 
-	expected := map[string]struct{}{
-		fmt.Sprintf("%v", []string{"A", "B"}): {},
-		fmt.Sprintf("%v", []string{"C"}):      {},
-		fmt.Sprintf("%v", []string{"A", "D"}): {},
+	mspId := func(principal *msp.MSPPrincipal) string {
+		role := &msp.MSPRole{}
+		proto.Unmarshal(principal.Principal, role)
+		return role.MspIdentifier
 	}
 
-	actual := make(map[string]struct{})
-	for _, ps := range satisfiedBy {
-		var principals []string
-		for _, principal := range ps {
-			principals = append(principals, mspId(principal))
-		}
-		actual[fmt.Sprintf("%v", principals)] = struct{}{}
-	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			p, err := cauthdsl.FromString(test.policy)
+			assert.NoError(t, err)
 
-	assert.Equal(t, expected, actual)
+			ip := NewInquireableSignaturePolicy(p)
+			satisfiedBy := ip.SatisfiedBy()
 
-	// Bad path: Remove an identity and re-try
-	p1.Identities = p1.Identities[1:]
-	ip = NewInquireableSignaturePolicy(p1)
-	satisfiedBy = ip.SatisfiedBy()
-	assert.Nil(t, satisfiedBy)
+			actual := make(map[string]struct{})
+			for _, ps := range satisfiedBy {
+				var principals []string
+				for _, principal := range ps {
+					principals = append(principals, mspId(principal))
+				}
+				actual[fmt.Sprintf("%v", principals)] = struct{}{}
+			}
+
+			assert.Equal(t, test.expected, actual)
+		})
+	}
 }