From b4a47bc2284f0dc034d8bb1f6c6d5044e104bc76 Mon Sep 17 00:00:00 2001 From: m1093782566 Date: Mon, 18 Dec 2017 17:20:06 +0800 Subject: [PATCH 1/4] implement fakeIPSet in ipset util --- pkg/util/ipset/testing/fake.go | 100 ++++++++++++++---- pkg/util/ipset/testing/fake_test.go | 152 ++++++++++++++++++++++++++++ 2 files changed, 232 insertions(+), 20 deletions(-) create mode 100644 pkg/util/ipset/testing/fake_test.go diff --git a/pkg/util/ipset/testing/fake.go b/pkg/util/ipset/testing/fake.go index aedf3d21b3b..2a58bdd399d 100644 --- a/pkg/util/ipset/testing/fake.go +++ b/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. -func NewFake() *FakeIPSet { - return &FakeIPSet{} +// NewFake create a new fake ipset interface - it initialize the FakeIPSet. +func NewFake(version string) *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) { - return "0.0", nil +func (f *FakeIPSet) GetVersion() (string, error) { + return f.Version, nil } -// FlushSet is part of interface. -func (*FakeIPSet) FlushSet(set string) error { +// FlushSet is part of interface. It deletes all entries from a named set but keeps the set itself. +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. -func (*FakeIPSet) DestroySet(set string) error { +// DestroySet is part of interface. It deletes both the entries and the set itself. +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) { - return true, nil +func (f *FakeIPSet) TestEntry(entry string, set string) (bool, error) { + 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) { - return nil, nil +func (f *FakeIPSet) ListEntries(set string) ([]string, error) { + 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) { - return nil, nil +func (f *FakeIPSet) ListSets() ([]string, error) { + res := []string{} + for set := range f.Sets { + res = append(res, set) + } + return res, nil } var _ = ipset.Interface(&FakeIPSet{}) diff --git a/pkg/util/ipset/testing/fake_test.go b/pkg/util/ipset/testing/fake_test.go new file mode 100644 index 00000000000..2128395cf8e --- /dev/null +++ b/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 From 6a5990caa0328f49dced9573cc138ba3041d50ff Mon Sep 17 00:00:00 2001 From: m1093782566 Date: Wed, 20 Dec 2017 15:53:43 +0800 Subject: [PATCH 2/4] add tests in ipvs/ipset_test.go --- pkg/proxy/ipvs/ipset_test.go | 133 +++++++++++++++++++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/pkg/proxy/ipvs/ipset_test.go b/pkg/proxy/ipvs/ipset_test.go index f1e1975dd29..d6a0dc7a926 100644 --- a/pkg/proxy/ipvs/ipset_test.go +++ b/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") + } + } + } +} From 15f427ac2c67ab75d573b7ee4aa4596733588cf0 Mon Sep 17 00:00:00 2001 From: m1093782566 Date: Wed, 20 Dec 2017 15:54:07 +0800 Subject: [PATCH 3/4] fix ipvs/proxier_test.go compile error --- pkg/proxy/ipvs/proxier_test.go | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/pkg/proxy/ipvs/proxier_test.go b/pkg/proxy/ipvs/proxier_test.go index f1b27ec525c..b962685440e 100644 --- a/pkg/proxy/ipvs/proxier_test.go +++ b/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 From 0f201037bdc651b6ee60208a704e5f0f50550283 Mon Sep 17 00:00:00 2001 From: m1093782566 Date: Wed, 20 Dec 2017 16:02:14 +0800 Subject: [PATCH 4/4] update bazel BUILD --- pkg/util/ipset/testing/BUILD | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/pkg/util/ipset/testing/BUILD b/pkg/util/ipset/testing/BUILD index 593b04157ca..001a6887b23 100644 --- a/pkg/util/ipset/testing/BUILD +++ b/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", + ], +)