Merge pull request #57438 from m1093782566/ipset-util-test

Automatic merge from submit-queue (batch tested with PRs 57292, 56274, 57435, 57438, 57429). If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>.

Implement FakeIPSet so that can add tests in IPVS proxier

**What this PR does / why we need it**:

Implement FakeIPSet so that can add tests in IPVS proxier - the tests can run everywhere(linux, mac, windows...).

**Which issue(s) this PR fixes**:
Fixes #57439

**Special notes for your reviewer**:

**Release note**:

```release-note
NONE
```

/assign @thockin @brendandburns

pkg/proxy/ipvs/ipset_test.go

@@ -18,6 +18,9 @@ package ipvs
 
 import (
 	"testing"
+
+	utilipset "k8s.io/kubernetes/pkg/util/ipset"
+	fakeipset "k8s.io/kubernetes/pkg/util/ipset/testing"
 )
 
 func TestCheckIPSetVersion(t *testing.T) {
@@ -47,3 +50,133 @@ func TestCheckIPSetVersion(t *testing.T) {
 		}
 	}
 }
+
+const testIPSetVersion = "v6.19"
+
+func TestSyncIPSetEntries(t *testing.T) {
+	testCases := []struct {
+		setName         string
+		setType         utilipset.Type
+		ipv6            bool
+		activeEntries   []string
+		currentEntries  []string
+		expectedEntries []string
+	}{
+		{ // case 0
+			setName:         "foo",
+			setType:         utilipset.HashIPPort,
+			ipv6:            false,
+			activeEntries:   []string{"172.17.0.4,tcp:80"},
+			currentEntries:  nil,
+			expectedEntries: []string{"172.17.0.4,tcp:80"},
+		},
+		{ // case 1
+			setName:         "abz",
+			setType:         utilipset.HashIPPort,
+			ipv6:            true,
+			activeEntries:   []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
+			currentEntries:  []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
+			expectedEntries: []string{"FE80::0202:B3FF:FE1E:8329,tcp:80"},
+		},
+		{ // case 2
+			setName:         "bca",
+			setType:         utilipset.HashIPPort,
+			ipv6:            false,
+			activeEntries:   []string{"172.17.0.4,tcp:80", "172.17.0.5,tcp:80"},
+			currentEntries:  []string{"172.17.0.5,udp:53"},
+			expectedEntries: []string{"172.17.0.4,tcp:80", "172.17.0.5,tcp:80"},
+		},
+		{ // case 3
+			setName:         "bar",
+			setType:         utilipset.HashIPPortIP,
+			ipv6:            false,
+			activeEntries:   []string{"172.17.0.4,tcp:80:172.17.0.4"},
+			currentEntries:  []string{"172.17.0.4,tcp:80:172.17.0.4"},
+			expectedEntries: []string{"172.17.0.4,tcp:80:172.17.0.4"},
+		},
+		{ // case 4
+			setName:         "baz",
+			setType:         utilipset.HashIPPortIP,
+			ipv6:            true,
+			activeEntries:   []string{"FE80:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8080:FE80:0000:0000:0000:0202:B3FF:FE1E:8329"},
+			currentEntries:  []string{"1111:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8081:1111:0000:0000:0000:0202:B3FF:FE1E:8329:8081"},
+			expectedEntries: []string{"FE80:0000:0000:0000:0202:B3FF:FE1E:8329,tcp:8080:FE80:0000:0000:0000:0202:B3FF:FE1E:8329"},
+		},
+		{ // case 5
+			setName:         "NOPE",
+			setType:         utilipset.HashIPPortIP,
+			ipv6:            false,
+			activeEntries:   []string{"172.17.0.4,tcp:80,172.17.0.9", "172.17.0.5,tcp:80,172.17.0.10"},
+			currentEntries:  nil,
+			expectedEntries: []string{"172.17.0.4,tcp:80,172.17.0.9", "172.17.0.5,tcp:80,172.17.0.10"},
+		},
+		{ // case 6
+			setName:         "ABC-DEF",
+			setType:         utilipset.HashIPPortNet,
+			ipv6:            false,
+			activeEntries:   []string{"172.17.0.4,tcp:80,172.17.0.0/16", "172.17.0.5,tcp:80,172.17.0.0/16"},
+			currentEntries:  nil,
+			expectedEntries: []string{"172.17.0.4,tcp:80,172.17.0.0/16", "172.17.0.5,tcp:80,172.17.0.0/16"},
+		},
+		{ // case 7
+			setName:         "zar",
+			setType:         utilipset.HashIPPortNet,
+			ipv6:            true,
+			activeEntries:   []string{"FE80::8329,tcp:8800,2001:db8::/32"},
+			currentEntries:  []string{"FE80::8329,tcp:8800,2001:db8::/32"},
+			expectedEntries: []string{"FE80::8329,tcp:8800,2001:db8::/32"},
+		},
+		{ // case 8
+			setName:         "bbb",
+			setType:         utilipset.HashIPPortNet,
+			ipv6:            true,
+			activeEntries:   nil,
+			currentEntries:  []string{"FE80::8329,udp:8801,2001:db8::/32"},
+			expectedEntries: nil,
+		},
+		{ // case 9
+			setName:         "AAA",
+			setType:         utilipset.BitmapPort,
+			activeEntries:   nil,
+			currentEntries:  []string{"80"},
+			expectedEntries: nil,
+		},
+		{ // case 10
+			setName:         "c-c-c",
+			setType:         utilipset.BitmapPort,
+			activeEntries:   []string{"8080", "9090"},
+			currentEntries:  []string{"80"},
+			expectedEntries: []string{"8080", "9090"},
+		},
+		{ // case 11
+			setName:         "NODE-PORT",
+			setType:         utilipset.BitmapPort,
+			activeEntries:   []string{"8080"},
+			currentEntries:  []string{"80", "9090", "8081", "8082"},
+			expectedEntries: []string{"8080"},
+		},
+	}
+
+	for i := range testCases {
+		set := NewIPSet(fakeipset.NewFake(testIPSetVersion), testCases[i].setName, testCases[i].setType, testCases[i].ipv6)
+
+		if err := set.handle.CreateSet(&set.IPSet, true); err != nil {
+			t.Errorf("Unexpected error: %v", err)
+		}
+		for _, entry := range testCases[i].expectedEntries {
+			set.handle.AddEntry(entry, testCases[i].setName, true)
+		}
+
+		set.activeEntries.Insert(testCases[i].activeEntries...)
+		set.syncIPSetEntries()
+		for _, entry := range testCases[i].expectedEntries {
+			found, err := set.handle.TestEntry(entry, testCases[i].setName)
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+			}
+			if !found {
+				t.Errorf("Unexpected entry 172.17.0.4,tcp:80 not found in set foo")
+			}
+		}
+	}
+}

pkg/proxy/ipvs/proxier_test.go

@@ -344,7 +344,7 @@ func TestGetNodeIPs(t *testing.T) {
 func TestNodePort(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	nodeIPv4 := net.ParseIP("100.101.102.103")
 	nodeIPv6 := net.ParseIP("2001:db8::1:1")
 	nodeIPs := sets.NewString(nodeIPv4.String(), nodeIPv6.String())
@@ -422,7 +422,7 @@ func TestNodePort(t *testing.T) {
 func TestNodePortNoEndpoint(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	nodeIP := net.ParseIP("100.101.102.103")
 	fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
 	svcIP := "10.20.30.41"
@@ -476,7 +476,7 @@ func TestNodePortNoEndpoint(t *testing.T) {
 func TestClusterIPNoEndpoint(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 	svcIP := "10.20.30.41"
 	svcPort := 80
@@ -520,7 +520,7 @@ func TestClusterIPNoEndpoint(t *testing.T) {
 func TestClusterIP(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 
 	svcIPv4 := "10.20.30.41"
@@ -627,7 +627,7 @@ func TestClusterIP(t *testing.T) {
 func TestExternalIPsNoEndpoint(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 	svcIP := "10.20.30.41"
 	svcPort := 80
@@ -682,7 +682,7 @@ func TestExternalIPsNoEndpoint(t *testing.T) {
 func TestExternalIPs(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 	svcIP := "10.20.30.41"
 	svcPort := 80
@@ -752,7 +752,7 @@ func TestExternalIPs(t *testing.T) {
 func TestLoadBalancer(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 	svcIP := "10.20.30.41"
 	svcPort := 80
@@ -804,7 +804,7 @@ func strPtr(s string) *string {
 func TestOnlyLocalNodePorts(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	nodeIP := net.ParseIP("100.101.102.103")
 	fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
 	svcIP := "10.20.30.41"
@@ -882,11 +882,10 @@ func TestOnlyLocalNodePorts(t *testing.T) {
 	}
 }
 
-// NO help
 func TestOnlyLocalLoadBalancing(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 	svcIP := "10.20.30.41"
 	svcPort := 80
@@ -951,7 +950,7 @@ func addTestPort(array []api.ServicePort, name string, protocol api.Protocol, po
 func TestBuildServiceMapAddRemove(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 
 	services := []*api.Service{
@@ -1057,7 +1056,7 @@ func TestBuildServiceMapAddRemove(t *testing.T) {
 func TestBuildServiceMapServiceHeadless(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 
 	makeServiceMap(fp,
@@ -1091,7 +1090,7 @@ func TestBuildServiceMapServiceHeadless(t *testing.T) {
 func TestBuildServiceMapServiceTypeExternalName(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 
 	makeServiceMap(fp,
@@ -1119,7 +1118,7 @@ func TestBuildServiceMapServiceTypeExternalName(t *testing.T) {
 func TestBuildServiceMapServiceUpdate(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 
 	servicev1 := makeTestService("somewhere", "some-service", func(svc *api.Service) {
@@ -1202,7 +1201,7 @@ func TestBuildServiceMapServiceUpdate(t *testing.T) {
 func TestSessionAffinity(t *testing.T) {
 	ipt := iptablestest.NewFake()
 	ipvs := ipvstest.NewFake()
-	ipset := ipsettest.NewFake()
+	ipset := ipsettest.NewFake(testIPSetVersion)
 	nodeIP := net.ParseIP("100.101.102.103")
 	fp := NewFakeProxier(ipt, ipvs, ipset, []net.IP{nodeIP})
 	svcIP := "10.20.30.41"
@@ -2066,7 +2065,7 @@ func Test_updateEndpointsMap(t *testing.T) {
 	for tci, tc := range testCases {
 		ipt := iptablestest.NewFake()
 		ipvs := ipvstest.NewFake()
-		ipset := ipsettest.NewFake()
+		ipset := ipsettest.NewFake(testIPSetVersion)
 		fp := NewFakeProxier(ipt, ipvs, ipset, nil)
 		fp.hostname = nodeName
 

pkg/util/ipset/testing/BUILD

@@ -1,11 +1,14 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
     srcs = ["fake.go"],
     importpath = "k8s.io/kubernetes/pkg/util/ipset/testing",
     visibility = ["//visibility:public"],
-    deps = ["//pkg/util/ipset:go_default_library"],
+    deps = [
+        "//pkg/util/ipset:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+    ],
 )
 
 filegroup(
@@ -21,3 +24,14 @@ filegroup(
     tags = ["automanaged"],
     visibility = ["//visibility:public"],
 )
+
+go_test(
+    name = "go_default_test",
+    srcs = ["fake_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/util/ipset/testing",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/util/ipset:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/sets:go_default_library",
+    ],
+)

pkg/util/ipset/testing/fake.go

@@ -17,67 +17,127 @@ limitations under the License.
 package testing
 
 import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/ipset"
 )
 
 // FakeIPSet is a no-op implementation of ipset Interface
 type FakeIPSet struct {
-	Lines []byte
+	// version of ipset util
+	Version string
+	// The key of Sets map is the ip set name
+	Sets map[string]*ipset.IPSet
+	// The key of Entries map is the ip set name where the entries exists
+	Entries map[string]sets.String
 }
 
-// NewFake create a new fake ipset interface.
+// NewFake create a new fake ipset interface - it initialize the FakeIPSet.
-func NewFake() *FakeIPSet {
+func NewFake(version string) *FakeIPSet {
-	return &FakeIPSet{}
+	return &FakeIPSet{
+		Version: version,
+		Sets:    make(map[string]*ipset.IPSet),
+		Entries: make(map[string]sets.String),
+	}
 }
 
 // GetVersion is part of interface.
-func (*FakeIPSet) GetVersion() (string, error) {
+func (f *FakeIPSet) GetVersion() (string, error) {
-	return "0.0", nil
+	return f.Version, nil
 }
 
-// FlushSet is part of interface.
+// FlushSet is part of interface.  It deletes all entries from a named set but keeps the set itself.
-func (*FakeIPSet) FlushSet(set string) error {
+func (f *FakeIPSet) FlushSet(set string) error {
+	if f.Entries == nil {
+		return fmt.Errorf("entries map can't be nil")
+	}
+
+	// delete all entry elements
+	for true {
+		if _, has := f.Entries[set].PopAny(); has {
+			continue
+		}
+		break
+	}
 	return nil
 }
 
-// DestroySet is part of interface.
+// DestroySet is part of interface.  It deletes both the entries and the set itself.
-func (*FakeIPSet) DestroySet(set string) error {
+func (f *FakeIPSet) DestroySet(set string) error {
+	delete(f.Sets, set)
+	delete(f.Entries, set)
 	return nil
 }
 
 // DestroyAllSets is part of interface.
-func (*FakeIPSet) DestroyAllSets() error {
+func (f *FakeIPSet) DestroyAllSets() error {
+	f.Sets = nil
+	f.Entries = nil
 	return nil
 }
 
 // CreateSet is part of interface.
-func (*FakeIPSet) CreateSet(set *ipset.IPSet, ignoreExistErr bool) error {
+func (f *FakeIPSet) CreateSet(set *ipset.IPSet, ignoreExistErr bool) error {
+	if f.Sets[set.Name] != nil {
+		if !ignoreExistErr {
+			// already exists
+			return fmt.Errorf("Set cannot be created: set with the same name already exists")
+		}
+		return nil
+	}
+	f.Sets[set.Name] = set
+	// initialize entry map
+	f.Entries[set.Name] = sets.NewString()
 	return nil
 }
 
 // AddEntry is part of interface.
-func (*FakeIPSet) AddEntry(entry string, set string, ignoreExistErr bool) error {
+func (f *FakeIPSet) AddEntry(entry string, set string, ignoreExistErr bool) error {
+	if f.Entries[set].Has(entry) {
+		if !ignoreExistErr {
+			// already exists
+			return fmt.Errorf("Element cannot be added to the set: it's already added")
+		}
+		return nil
+	}
+	f.Entries[set].Insert(entry)
 	return nil
 }
 
 // DelEntry is part of interface.
-func (*FakeIPSet) DelEntry(entry string, set string) error {
+func (f *FakeIPSet) DelEntry(entry string, set string) error {
+	if f.Entries == nil {
+		return fmt.Errorf("entries map can't be nil")
+	}
+	f.Entries[set].Delete(entry)
 	return nil
 }
 
 // TestEntry is part of interface.
-func (*FakeIPSet) TestEntry(entry string, set string) (bool, error) {
+func (f *FakeIPSet) TestEntry(entry string, set string) (bool, error) {
-	return true, nil
+	if f.Entries == nil {
+		return false, fmt.Errorf("entries map can't be nil")
+	}
+	found := f.Entries[set].Has(entry)
+	return found, nil
 }
 
 // ListEntries is part of interface.
-func (*FakeIPSet) ListEntries(set string) ([]string, error) {
+func (f *FakeIPSet) ListEntries(set string) ([]string, error) {
-	return nil, nil
+	if f.Entries == nil {
+		return nil, fmt.Errorf("entries map can't be nil")
+	}
+	return f.Entries[set].UnsortedList(), nil
 }
 
 // ListSets is part of interface.
-func (*FakeIPSet) ListSets() ([]string, error) {
+func (f *FakeIPSet) ListSets() ([]string, error) {
-	return nil, nil
+	res := []string{}
+	for set := range f.Sets {
+		res = append(res, set)
+	}
+	return res, nil
 }
 
 var _ = ipset.Interface(&FakeIPSet{})

pkg/util/ipset/testing/fake_test.go

@@ -0,0 +1,152 @@
+/*
+Copyright 2017 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package testing
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/pkg/util/ipset"
+)
+
+const testVersion = "v6.19"
+
+func TestSetEntry(t *testing.T) {
+	fake := NewFake(testVersion)
+	version, err := fake.GetVersion()
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if version != testVersion {
+		t.Errorf("Unexpected version mismatch, expected: %s, got: %s", testVersion, version)
+	}
+	// create a set
+	set := &ipset.IPSet{
+		Name:       "foo",
+		SetType:    ipset.HashIPPort,
+		HashFamily: ipset.ProtocolFamilyIPV4,
+	}
+	if err := fake.CreateSet(set, true); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+
+	// add two entries
+	fake.AddEntry("192.168.1.1,tcp:8080", set.Name, true)
+	fake.AddEntry("192.168.1.2,tcp:8081", set.Name, true)
+	entries, err := fake.ListEntries(set.Name)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(entries) != 2 {
+		t.Errorf("Expected 2 entries, got %d", len(entries))
+	}
+	expectedEntries := sets.NewString("192.168.1.1,tcp:8080", "192.168.1.2,tcp:8081")
+	if !expectedEntries.Equal(sets.NewString(entries...)) {
+		t.Errorf("Unexpected entries mismatch, expected: %v, got: %v", expectedEntries, entries)
+	}
+
+	// test entries
+	found, err := fake.TestEntry("192.168.1.1,tcp:8080", set.Name)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if !found {
+		t.Errorf("Unexpected entry 192.168.1.1,tcp:8080 not found")
+	}
+
+	found, err = fake.TestEntry("192.168.1.2,tcp:8081", set.Name)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if !found {
+		t.Errorf("Unexpected entry 192.168.1.2,tcp:8081 not found")
+	}
+
+	// delete entry from a given set
+	if err := fake.DelEntry("192.168.1.1,tcp:8080", set.Name); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	entries, err = fake.ListEntries(set.Name)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Errorf("Expected 1 entries, got %d", len(entries))
+	}
+	expectedEntries = sets.NewString("192.168.1.2,tcp:8081")
+	if !expectedEntries.Equal(sets.NewString(entries...)) {
+		t.Errorf("Unexpected entries mismatch, expected: %v, got: %v", expectedEntries, entries)
+	}
+
+	// Flush set
+	if err := fake.FlushSet(set.Name); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	entries, err = fake.ListEntries(set.Name)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(entries) != 0 {
+		t.Errorf("Expected 0 entries, got %d, entries: %v", len(entries), entries)
+	}
+
+	// create another set
+	set2 := &ipset.IPSet{
+		Name:       "bar",
+		SetType:    ipset.HashIPPortIP,
+		HashFamily: ipset.ProtocolFamilyIPV6,
+	}
+	if err := fake.CreateSet(set2, true); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+
+	setList, err := fake.ListSets()
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(setList) != 2 {
+		t.Errorf("Expected 2 sets, got %d", len(setList))
+	}
+	expectedSets := sets.NewString("foo", "bar")
+	if !expectedSets.Equal(sets.NewString(setList...)) {
+		t.Errorf("Unexpected sets mismatch, expected: %v, got: %v", expectedSets, setList)
+	}
+
+	// Destroy a given set
+	if err := fake.DestroySet(set.Name); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if fake.Sets[set.Name] != nil {
+		t.Errorf("Unexpected set: %v", fake.Sets[set.Name])
+	}
+	if fake.Entries[set.Name] != nil {
+		t.Errorf("Unexpected entries: %v", fake.Entries[set.Name])
+	}
+
+	// Destroy all sets
+	if err := fake.DestroyAllSets(); err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if len(fake.Sets) != 0 {
+		t.Errorf("Expected 0 sets, got %d, sets: %v", len(fake.Sets), fake.Sets)
+	}
+	if len(fake.Entries) != 0 {
+		t.Errorf("Expected 0 entries, got %d, entries: %v", len(fake.Entries), fake.Entries)
+	}
+}
+
+// TODO: Test ignoreExistErr=false