Update slice comparisons to use slices package

Author: mdbooth

pkg/cloud/services/loadbalancer/loadbalancer.go

@@ -19,6 +19,7 @@ package loadbalancer
 import (
 	"errors"
 	"fmt"
+	"slices"
 	"time"
 
 	"github.com/gophercloud/gophercloud/openstack/loadbalancer/v2/listeners"
@@ -274,11 +275,11 @@ func (s *Service) getOrUpdateAllowedCIDRS(openStackCluster *infrav1.OpenStackClu
 	// Validate CIDRs and convert any given IP into a CIDR.
 	allowedCIDRs = validateIPs(openStackCluster, allowedCIDRs)
 
-	// Remove duplicates.
-	allowedCIDRs = capostrings.Unique(allowedCIDRs)
-	listener.AllowedCIDRs = capostrings.Unique(listener.AllowedCIDRs)
+	// Sort and remove duplicates
+	allowedCIDRs = capostrings.Canonicalize(allowedCIDRs)
+	listener.AllowedCIDRs = capostrings.Canonicalize(listener.AllowedCIDRs)
 
-	if !capostrings.CompareLists(allowedCIDRs, listener.AllowedCIDRs) {
+	if !slices.Equal(allowedCIDRs, listener.AllowedCIDRs) {
 		s.scope.Logger().Info("CIDRs do not match, updating listener", "expectedCIDRs", allowedCIDRs, "currentCIDRs", listener.AllowedCIDRs)
 		listenerUpdateOpts := listeners.UpdateOpts{
 			AllowedCIDRs: &allowedCIDRs,

pkg/utils/strings/strings.go

@@ -16,33 +16,12 @@ limitations under the License.
 
 package strings
 
-func Unique(s []string) []string {
-	inResult := make(map[string]bool)
-	var result []string
-	for _, str := range s {
-		if _, ok := inResult[str]; !ok {
-			inResult[str] = true
-			result = append(result, str)
-		}
-	}
-	return result
-}
+import (
+	"cmp"
+	"slices"
+)
 
-func CompareLists(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for _, v := range a {
-		eq := false
-		for _, v2 := range b {
-			if v == v2 {
-				eq = true
-				break
-			}
-		}
-		if !eq {
-			return false
-		}
-	}
-	return true
+func Canonicalize[S ~[]E, E cmp.Ordered](s S) S {
+	slices.Sort(s)
+	return slices.Compact(s)
 }

pkg/utils/strings/strings_test.go

@@ -17,52 +17,42 @@ limitations under the License.
 package strings
 
 import (
+	"slices"
 	"testing"
 )
 
-func TestCompareLists(t *testing.T) {
+func TestCanonicalize(t *testing.T) {
 	tests := []struct {
-		name string
-		a    []string
-		b    []string
-		want bool
+		name  string
+		value []string
+		want  []string
 	}{
 		{
-			name: "Empty lists",
-			a:    []string{},
-			b:    []string{},
-			want: true,
+			name:  "Empty list",
+			value: []string{},
+			want:  []string{},
 		},
 		{
-			name: "Equal lists",
-			a:    []string{"a", "b", "c"},
-			b:    []string{"a", "b", "c"},
-			want: true,
+			name:  "Identity",
+			value: []string{"a", "b", "c"},
+			want:  []string{"a", "b", "c"},
 		},
 		{
-			name: "Different order",
-			a:    []string{"a", "b", "c"},
-			b:    []string{"c", "b", "a"},
-			want: true,
+			name:  "Out of order",
+			value: []string{"c", "b", "a"},
+			want:  []string{"a", "b", "c"},
 		},
 		{
-			name: "Different elements",
-			a:    []string{"a", "b", "c"},
-			b:    []string{"d", "e", "f"},
-			want: false,
-		},
-		{
-			name: "Different lengths",
-			a:    []string{"a", "b", "c"},
-			b:    []string{"a", "b"},
-			want: false,
+			name:  "Duplicate elements",
+			value: []string{"c", "b", "a", "c"},
+			want:  []string{"a", "b", "c"},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got := CompareLists(tt.a, tt.b)
-			if got != tt.want {
+			got := Canonicalize(tt.value)
+			if !slices.Equal(got, tt.want) {
 				t.Errorf("CompareLists() = %v, want %v", got, tt.want)
 			}
 		})