Update switches, remove set

`set` is removed due to official support in k8s' `sets` package.
Fix the `switches` package and add `AnyEnabled`, `AllEnabled` and
`Values`.

Author: adracus

cmdutils/switches/switches.go

@@ -22,7 +22,7 @@ import (
 	"sort"
 	"strings"
 
-	"github.com/onmetal/controller-utils/set"
+	"k8s.io/apimachinery/pkg/util/sets"
 )
 
 const (
@@ -118,14 +118,34 @@ func (s *Switches) Enabled(name string) bool {
 	return s.settings[name]
 }
 
+// AllEnabled checks whether all switches with the given names are enabled.
+func (s *Switches) AllEnabled(names ...string) bool {
+	for _, name := range names {
+		if !s.settings[name] {
+			return false
+		}
+	}
+	return true
+}
+
+// AnyEnabled checks whether any switch of the given names is enabled.
+func (s *Switches) AnyEnabled(names ...string) bool {
+	for _, name := range names {
+		if s.settings[name] {
+			return true
+		}
+	}
+	return false
+}
+
 // All returns names of all items set in settings
-func (s *Switches) All() set.Set[string] {
-	return set.Keys(s.defaults)
+func (s *Switches) All() sets.Set[string] {
+	return sets.KeySet(s.defaults)
 }
 
 // Active returns names of all active items
-func (s *Switches) Active() set.Set[string] {
-	names := set.New[string]()
+func (s *Switches) Active() sets.Set[string] {
+	names := sets.New[string]()
 	for k, enabled := range s.settings {
 		if enabled {
 			names.Insert(k)
@@ -135,9 +155,18 @@ func (s *Switches) Active() set.Set[string] {
 	return names
 }
 
+// Values returns the switches with their values.
+func (s *Switches) Values() map[string]bool {
+	res := make(map[string]bool, len(s.defaults))
+	for key := range s.defaults {
+		res[key] = s.settings[key]
+	}
+	return res
+}
+
 // EnabledByDefault returns names of all enabled items
-func (s *Switches) EnabledByDefault() set.Set[string] {
-	names := set.New[string]()
+func (s *Switches) EnabledByDefault() sets.Set[string] {
+	names := sets.New[string]()
 	for k, enabled := range s.defaults {
 		if enabled {
 			names.Insert(k)
@@ -148,8 +177,8 @@ func (s *Switches) EnabledByDefault() set.Set[string] {
 }
 
 // DisabledByDefault returns names of all disabled items
-func (s *Switches) DisabledByDefault() set.Set[string] {
-	names := set.New[string]()
+func (s *Switches) DisabledByDefault() sets.Set[string] {
+	names := sets.New[string]()
 	for k, enabled := range s.defaults {
 		if !enabled {
 			names.Insert(k)

cmdutils/switches/switches_test.go

@@ -16,136 +16,239 @@ package switches
 import (
 	"flag"
 
-	"github.com/onmetal/controller-utils/set"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	"github.com/spf13/pflag"
+	"k8s.io/apimachinery/pkg/util/sets"
 )
 
 var _ = Describe("CMD Switches", func() {
 	Context("Testing Switches interface", func() {
-		It("should disable runner", func() {
-			s := New("runner-a", "runner-b")
-			Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
-			Expect(s.Enabled("runner-a")).To(BeTrue())
-			Expect(s.Enabled("runner-b")).To(BeFalse())
+		Describe("Enabled", func() {
+			It("should return whether an item is enabled or not", func() {
+				s := New("runner-a", "runner-b")
+				Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
+
+				Expect(s.Enabled("runner-a")).To(BeTrue())
+				Expect(s.Enabled("runner-b")).To(BeFalse())
+			})
 		})
-		It("should return all items", func() {
-			s := New("runner-a", "runner-b", Disable("runner-c"))
-			Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
 
-			expected := set.New("runner-a", "runner-b", "runner-c")
-			Expect(s.All()).To(Equal(expected))
+		Describe("AllEnabled", func() {
+			It("should return true when all given switches are enabled", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AllEnabled("runner-a", "runner-c")).To(BeTrue())
+			})
+
+			It("should return false if any of the given switches is not enabled", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AllEnabled("runner-a", "runner-b")).To(BeFalse())
+			})
+
+			It("should return true on empty arguments", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AllEnabled()).To(BeTrue())
+			})
 		})
-		It("should return only active items", func() {
-			s := New("runner-a", "runner-b", Disable("runner-c"))
-			Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
 
-			expected := set.New("runner-a")
-			Expect(s.Active()).To(Equal(expected))
+		Describe("AnyEnabled", func() {
+			It("should return true when any of the given switches is enabled", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AnyEnabled("runner-a", "runner-b")).To(BeTrue())
+			})
+
+			It("should return false if all of the given switches are not enabled", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AnyEnabled("runner-b")).To(BeFalse())
+			})
+
+			It("should return false on empty arguments", func() {
+				s := New("runner-a", Disable("runner-b"), "runner-c")
+				Expect(s.Set("*")).NotTo(HaveOccurred())
+
+				Expect(s.AnyEnabled()).To(BeFalse())
+			})
 		})
-		It("should return all enabled items", func() {
-			s := New("runner-a", Disable("runner-b"))
 
-			expected := set.New("runner-a")
-			Expect(s.EnabledByDefault()).To(Equal(expected))
+		Describe("Values", func() {
+			It("should return the switches with their values", func() {
+				s := New("runner-a", "runner-b")
+				Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
+
+				Expect(s.Values()).To(Equal(map[string]bool{
+					"runner-a": true,
+					"runner-b": false,
+				}))
+			})
 		})
-		It("should return all disabled items", func() {
-			s := New("runner-a", Disable("runner-b"))
 
-			expected := set.New("runner-b")
-			Expect(s.DisabledByDefault()).To(Equal(expected))
+		Describe("All", func() {
+			It("should return all items", func() {
+				s := New("runner-a", "runner-b", Disable("runner-c"))
+				Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
+
+				Expect(s.All()).To(Equal(sets.New("runner-a", "runner-b", "runner-c")))
+			})
 		})
-		It("should return string", func() {
-			s := New("runner-a", "runner-b")
-			Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
-			Expect(s.String()).To(Equal("runner-a,-runner-b"))
+
+		Describe("Active", func() {
+			It("should return all enabled items", func() {
+				s := New("runner-a", "runner-b", Disable("runner-c"))
+				Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
+
+				Expect(s.Active()).To(Equal(sets.New("runner-a")))
+			})
+		})
+
+		Describe("EnabledByDefault", func() {
+			It("should return all items that are enabled by default", func() {
+				s := New("runner-a", Disable("runner-b"))
+
+				Expect(s.EnabledByDefault()).To(Equal(sets.New("runner-a")))
+			})
+		})
+
+		Describe("DisabledByDefault", func() {
+			It("should return all items disabled by default", func() {
+				s := New("runner-a", Disable("runner-b"))
+
+				Expect(s.DisabledByDefault()).To(Equal(sets.New("runner-b")))
+			})
+		})
+
+		Describe("String", func() {
+			It("should return a string repressentation of the switches", func() {
+				s := New("runner-a", "runner-b")
+				Expect(s.Set("*,-runner-b")).ToNot(HaveOccurred())
+
+				Expect(s.String()).To(Equal("runner-a,-runner-b"))
+			})
 		})
 	})
 
-	Context("Testing flag package behavior", func() {
+	Describe("goflag.Parse", func() {
 		It("should disable all controllers when no flag is passed", func() {
 			fs := flag.NewFlagSet("", flag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeFalse())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeFalse())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": false,
+				"runner-b": false,
+				"runner-c": false,
+			}))
 		})
+
 		It("should keep default settings when * is passed", func() {
 			fs := flag.NewFlagSet("", flag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=*"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeTrue())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeTrue())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": true,
+				"runner-b": false,
+				"runner-c": true,
+			}))
 		})
+
 		It("should override default settings", func() {
 			fs := flag.NewFlagSet("", flag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=runner-a,-runner-c"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeTrue())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeFalse())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": true,
+				"runner-b": false,
+				"runner-c": false,
+			}))
 		})
+
 		It("should override some of default settings", func() {
 			fs := flag.NewFlagSet("", flag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=*,-runner-a"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeFalse())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeTrue())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": false,
+				"runner-b": false,
+				"runner-c": true,
+			}))
 		})
 	})
 
-	Context("Testing pflag package behavior", func() {
+	Describe("pflag.parse", func() {
 		It("should disable all controllers when no flag is passed", func() {
 			fs := pflag.NewFlagSet("", pflag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeFalse())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeFalse())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": false,
+				"runner-b": false,
+				"runner-c": false,
+			}))
 		})
+
 		It("should keep default settings when * is passed", func() {
 			fs := pflag.NewFlagSet("", pflag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=*"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeTrue())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeTrue())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": true,
+				"runner-b": false,
+				"runner-c": true,
+			}))
 		})
+
 		It("should override default settings", func() {
 			fs := pflag.NewFlagSet("", pflag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=runner-a,-runner-c"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeTrue())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeFalse())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": true,
+				"runner-b": false,
+				"runner-c": false,
+			}))
 		})
+
 		It("should override some of default settings", func() {
 			fs := pflag.NewFlagSet("", pflag.ExitOnError)
 			controllers := New("runner-a", Disable("runner-b"), "runner-c")
 			fs.Var(controllers, "controllers", "")
 
 			Expect(fs.Parse([]string{"--controllers=*,-runner-a"})).NotTo(HaveOccurred())
-			Expect(controllers.Enabled("runner-a")).To(BeFalse())
-			Expect(controllers.Enabled("runner-b")).To(BeFalse())
-			Expect(controllers.Enabled("runner-c")).To(BeTrue())
+
+			Expect(controllers.Values()).To(Equal(map[string]bool{
+				"runner-a": false,
+				"runner-b": false,
+				"runner-c": true,
+			}))
 		})
 	})
 })

go.mod

@@ -1,6 +1,6 @@
 module github.com/onmetal/controller-utils
 
-go 1.19
+go 1.20
 
 require (
 	github.com/golang/mock v1.6.0
@@ -9,7 +9,6 @@ require (
 	github.com/onsi/gomega v1.26.0
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.8.1
-	golang.org/x/exp v0.0.0-20221006183845-316c7553db56
 	k8s.io/api v0.26.1
 	k8s.io/apiextensions-apiserver v0.26.1
 	k8s.io/apimachinery v0.26.1

go.sum

@@ -416,8 +416,6 @@ golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/exp v0.0.0-20221006183845-316c7553db56 h1:BrYbdKcCNjLyrN6aKqXy4hPw9qGI8IATkj4EWv9Q+kQ=
-golang.org/x/exp v0.0.0-20221006183845-316c7553db56/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=