fix: fix permissions checking

core/grant/service.go

@@ -427,7 +427,7 @@ func reduceGrantsByProviderRole(rc *domain.ResourceConfig, grants []*domain.Gran
 	sort.Strings(allGrantPermissions)
 
 	for roleID, permissionsByRole := range rolePermissionsMap {
-		if containing, headIndex := utils.ContainsOrdered(allGrantPermissions, permissionsByRole); containing {
+		if containing, headIndex := utils.SubsliceExists(allGrantPermissions, permissionsByRole); containing {
 			sampleGrant := permissionGrantsMap[allGrantPermissions[0]]
 			sampleGrant.Role = roleID
 			sampleGrant.Permissions = permissionsByRole

utils/slices.go

@@ -1,29 +1,31 @@
 package utils
 
-func ContainsOrdered(ss []string, lookingFor []string) (bool, int) {
-	var headFound bool
-	var headFoundIndex int
+func SubsliceExists(slice, subslice []string) (bool, int) {
+	// check for empty subslice slice
+	if len(subslice) == 0 {
+		return true, 0
+	}
 
-	if len(lookingFor) <= 0 {
-		return true, headFoundIndex
+	// check if subslice slice is longer than slice
+	if len(subslice) > len(slice) {
+		return false, 0
 	}
-	head := lookingFor[0]
 
-	for i := 0; i < len(ss); i++ {
-		if !headFound && ss[i] != head {
-			// skip head mismatch
-			continue
-		} else if !headFound {
-			// mark position in ss when found matching head
-			headFound = true
-			headFoundIndex = i
-			continue
-		} else if ss[i] != lookingFor[i-headFoundIndex] {
-			// return false on first mismatch after head
-			return false, headFoundIndex
-		} else if len(lookingFor)-1 == i-headFoundIndex {
-			return true, headFoundIndex
+	// looking for a subslice
+	for i := 0; i < len(slice); i++ {
+		if slice[i] == subslice[0] {
+			found := true
+			for j := 1; j < len(subslice); j++ {
+				if slice[i+j] != subslice[j] {
+					found = false
+					break
+				}
+			}
+			if found {
+				return true, i
+			}
 		}
 	}
-	return false, headFoundIndex
+
+	return false, 0
 }

utils/slices_test.go

@@ -7,10 +7,10 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestContainsOrdered(t *testing.T) {
+func TestSubsliceExists(t *testing.T) {
 	testCases := []struct {
 		slice             []string
-		lookingFor        []string
+		subslice          []string
 		expectedResult    bool
 		expectedHeadIndex int
 	}{
@@ -30,7 +30,22 @@ func TestContainsOrdered(t *testing.T) {
 			true, 1,
 		},
 		{
-			// return true for empty `lookingFor` elements
+			[]string{"a", "b", "c"},
+			[]string{"b"},
+			true, 1,
+		},
+		{
+			[]string{"a", "b", "c", "b"},
+			[]string{"c"},
+			true, 2,
+		},
+		{
+			[]string{"a", "b", "c", "d"},
+			[]string{"b", "c", "d"},
+			true, 1,
+		},
+		{
+			// return true for empty `subslice` elements
 			[]string{"a", "b", "c", "d"},
 			[]string{},
 			true, 0,
@@ -48,12 +63,12 @@ func TestContainsOrdered(t *testing.T) {
 		{
 			[]string{"a", "b", "c", "d"},
 			[]string{"c", "c", "d"},
-			false, 2,
+			false, 0,
 		},
 		{
 			[]string{"a", "b", "c", "d"},
 			[]string{"b", "d"},
-			false, 1,
+			false, 0,
 		},
 		{
 			[]string{"a", "b", "c", "d"},
@@ -73,7 +88,7 @@ func TestContainsOrdered(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		result, headIndex := utils.ContainsOrdered(tc.slice, tc.lookingFor)
+		result, headIndex := utils.SubsliceExists(tc.slice, tc.subslice)
 		assert.Equal(t, tc.expectedResult, result)
 		assert.Equal(t, tc.expectedHeadIndex, headIndex)
 	}