Update go dependencies

vendor/k8s.io/client-go/util/buffer/ring_growing_test.go

@@ -1,50 +0,0 @@
-/*
-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 buffer
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGrowth(t *testing.T) {
-	t.Parallel()
-	x := 10
-	g := NewRingGrowing(1)
-	for i := 0; i < x; i++ {
-		assert.Equal(t, i, g.readable)
-		g.WriteOne(i)
-	}
-	read := 0
-	for g.readable > 0 {
-		v, ok := g.ReadOne()
-		assert.True(t, ok)
-		assert.Equal(t, read, v)
-		read++
-	}
-	assert.Equalf(t, x, read, "expected to have read %d items: %d", x, read)
-	assert.Zerof(t, g.readable, "expected readable to be zero: %d", g.readable)
-	assert.Equalf(t, g.n, 16, "expected N to be 16: %d", g.n)
-}
-
-func TestEmpty(t *testing.T) {
-	t.Parallel()
-	g := NewRingGrowing(1)
-	_, ok := g.ReadOne()
-	assert.False(t, ok)
-}

vendor/k8s.io/client-go/util/cert/csr_test.go

@@ -1,75 +0,0 @@
-/*
-Copyright 2016 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 cert
-
-import (
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"io/ioutil"
-	"net"
-	"testing"
-)
-
-func TestMakeCSR(t *testing.T) {
-	keyFile := "testdata/dontUseThisKey.pem"
-	subject := &pkix.Name{
-		CommonName: "kube-worker",
-	}
-	dnsSANs := []string{"localhost"}
-	ipSANs := []net.IP{net.ParseIP("127.0.0.1")}
-
-	keyData, err := ioutil.ReadFile(keyFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	key, err := ParsePrivateKeyPEM(keyData)
-	if err != nil {
-		t.Fatal(err)
-	}
-	csrPEM, err := MakeCSR(key, subject, dnsSANs, ipSANs)
-	if err != nil {
-		t.Error(err)
-	}
-	csrBlock, rest := pem.Decode(csrPEM)
-	if csrBlock == nil {
-		t.Error("Unable to decode MakeCSR result.")
-	}
-	if len(rest) != 0 {
-		t.Error("Found more than one PEM encoded block in the result.")
-	}
-	if csrBlock.Type != CertificateRequestBlockType {
-		t.Errorf("Found block type %q, wanted 'CERTIFICATE REQUEST'", csrBlock.Type)
-	}
-	csr, err := x509.ParseCertificateRequest(csrBlock.Bytes)
-	if err != nil {
-		t.Errorf("Found %v parsing MakeCSR result as a CertificateRequest.", err)
-	}
-	if csr.Subject.CommonName != subject.CommonName {
-		t.Errorf("Wanted %v, got %v", subject, csr.Subject)
-	}
-	if len(csr.DNSNames) != 1 {
-		t.Errorf("Wanted 1 DNS name in the result, got %d", len(csr.DNSNames))
-	} else if csr.DNSNames[0] != dnsSANs[0] {
-		t.Errorf("Wanted %v, got %v", dnsSANs[0], csr.DNSNames[0])
-	}
-	if len(csr.IPAddresses) != 1 {
-		t.Errorf("Wanted 1 IP address in the result, got %d", len(csr.IPAddresses))
-	} else if csr.IPAddresses[0].String() != ipSANs[0].String() {
-		t.Errorf("Wanted %v, got %v", ipSANs[0], csr.IPAddresses[0])
-	}
-}

vendor/k8s.io/client-go/util/cert/pem_test.go

@@ -1,197 +0,0 @@
-/*
-Copyright 2014 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 cert
-
-import (
-	"io/ioutil"
-	"os"
-	"testing"
-)
-
-const (
-	// rsaPrivateKey is a RSA Private Key in PKCS#1 format
-	// openssl genrsa -out rsa2048.pem 2048
-	rsaPrivateKey = `-----BEGIN RSA PRIVATE KEY-----
-MIIEpAIBAAKCAQEA92mVjhBKOFsdxFzb/Pjq+7b5TJlODAdY5hK+WxLZTIrfhDPq
-FWrGKdjSNiHbXrdEtwJh9V+RqPZVSN3aWy1224RgkyNdMJsXhJKuCC24ZKY8SXtW
-xuTYmMRaMnCsv6QBGRTIbZ2EFbAObVM7lDyv1VqY3amZIWFQMlZ9CNpxDSPa5yi4
-3gopbXkne0oGNmey9X0qtpk7NMZIgAL6Zz4rZ30bcfC2ag6RLOFI2E/c4n8c38R8
-9MfXfLkj8/Cxo4JfI9NvRCpPOpFO8d/ZtWVUuIrBQN+Y7tkN2T60Qq/TkKXUrhDe
-fwlTlktZVJ/GztLYU41b2GcWsh/XO+PH831rmwIDAQABAoIBAQCC9c6GDjVbM0/E
-WurPMusfJjE7zII1d8YkspM0HfwLug6qKdikUYpnKC/NG4rEzfl/bbFwco/lgc6O
-7W/hh2U8uQttlvCDA/Uk5YddKOZL0Hpk4vaB/SxxYK3luSKXpjY2knutGg2KdVCN
-qdsFkkH4iyYTXuyBcMNEgedZQldI/kEujIH/L7FE+DF5TMzT4lHhozDoG+fy564q
-qVGUZXJn0ubc3GaPn2QOLNNM44sfYA4UJCpKBXPu85bvNObjxVQO4WqwwxU1vRnL
-UUsaGaelhSVJCo0dVPRvrfPPKZ09HTwpy40EkgQo6VriFc1EBoQDjENLbAJv9OfQ
-aCc9wiZhAoGBAP/8oEy48Zbb0P8Vdy4djf5tfBW8yXFLWzXewJ4l3itKS1r42nbX
-9q3cJsgRTQm8uRcMIpWxsc3n6zG+lREvTkoTB3ViI7+uQPiqA+BtWyNy7jzufFke
-ONKZfg7QxxmYRWZBRnoNGNbMpNeERuLmhvQuom9D1WbhzAYJbfs/O4WTAoGBAPds
-2FNDU0gaesFDdkIUGq1nIJqRQDW485LXZm4pFqBFxdOpbdWRuYT2XZjd3fD0XY98
-Nhkpb7NTMCuK3BdKcqIptt+cK+quQgYid0hhhgZbpCQ5AL6c6KgyjgpYlh2enzU9
-Zo3yg8ej1zbbA11sBlhX+5iO2P1u5DG+JHLwUUbZAoGAUwaU102EzfEtsA4+QW7E
-hyjrfgFlNKHES4yb3K9bh57pIfBkqvcQwwMMcQdrfSUAw0DkVrjzel0mI1Q09QXq
-1ould6UFAz55RC2gZEITtUOpkYmoOx9aPrQZ9qQwb1S77ZZuTVfCHqjxLhVxCFbM
-npYhiQTvShciHTMhwMOZgpECgYAVV5EtVXBYltgh1YTc3EkUzgF087R7LdHsx6Gx
-POATwRD4WfP8aQ58lpeqOPEM+LcdSlSMRRO6fyF3kAm+BJDwxfJdRWZQXumZB94M
-I0VhRQRaj4Qt7PDwmTPBVrTUJzuKZxpyggm17b8Bn1Ch/VBqzGQKW8AB1E/grosM
-UwhfuQKBgQC2JO/iqTQScHClf0qlItCJsBuVukFmSAVCkpOD8YdbdlPdOOwSk1wQ
-C0eAlsC3BCMvkpidKQmra6IqIrvTGI6EFgkrb3aknWdup2w8j2udYCNqyE3W+fVe
-p8FdYQ1FkACQ+daO5VlClL/9l0sGjKXlNKbpmJ2H4ngZmXj5uGmxuQ==
------END RSA PRIVATE KEY-----`
-
-	// rsaPublicKey is a RSA Public Key in PEM encoded format
-	// openssl rsa -in rsa2048.pem -pubout -out rsa2048pub.pem
-	rsaPublicKey = `-----BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA92mVjhBKOFsdxFzb/Pjq
-+7b5TJlODAdY5hK+WxLZTIrfhDPqFWrGKdjSNiHbXrdEtwJh9V+RqPZVSN3aWy12
-24RgkyNdMJsXhJKuCC24ZKY8SXtWxuTYmMRaMnCsv6QBGRTIbZ2EFbAObVM7lDyv
-1VqY3amZIWFQMlZ9CNpxDSPa5yi43gopbXkne0oGNmey9X0qtpk7NMZIgAL6Zz4r
-Z30bcfC2ag6RLOFI2E/c4n8c38R89MfXfLkj8/Cxo4JfI9NvRCpPOpFO8d/ZtWVU
-uIrBQN+Y7tkN2T60Qq/TkKXUrhDefwlTlktZVJ/GztLYU41b2GcWsh/XO+PH831r
-mwIDAQAB
------END PUBLIC KEY-----`
-
-	// certificate is an x509 certificate in PEM encoded format
-	// openssl req -new -key rsa2048.pem -sha256 -nodes -x509 -days 1826 -out x509certificate.pem -subj "/C=US/CN=not-valid"
-	certificate = `-----BEGIN CERTIFICATE-----
-MIIDFTCCAf2gAwIBAgIJAN8B8NOwtiUCMA0GCSqGSIb3DQEBCwUAMCExCzAJBgNV
-BAYTAlVTMRIwEAYDVQQDDAlub3QtdmFsaWQwHhcNMTcwMzIyMDI1NjM2WhcNMjIw
-MzIyMDI1NjM2WjAhMQswCQYDVQQGEwJVUzESMBAGA1UEAwwJbm90LXZhbGlkMIIB
-IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA92mVjhBKOFsdxFzb/Pjq+7b5
-TJlODAdY5hK+WxLZTIrfhDPqFWrGKdjSNiHbXrdEtwJh9V+RqPZVSN3aWy1224Rg
-kyNdMJsXhJKuCC24ZKY8SXtWxuTYmMRaMnCsv6QBGRTIbZ2EFbAObVM7lDyv1VqY
-3amZIWFQMlZ9CNpxDSPa5yi43gopbXkne0oGNmey9X0qtpk7NMZIgAL6Zz4rZ30b
-cfC2ag6RLOFI2E/c4n8c38R89MfXfLkj8/Cxo4JfI9NvRCpPOpFO8d/ZtWVUuIrB
-QN+Y7tkN2T60Qq/TkKXUrhDefwlTlktZVJ/GztLYU41b2GcWsh/XO+PH831rmwID
-AQABo1AwTjAdBgNVHQ4EFgQU1I5GfinLF7ta+dBJ6UWcrYaexLswHwYDVR0jBBgw
-FoAU1I5GfinLF7ta+dBJ6UWcrYaexLswDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0B
-AQsFAAOCAQEAUl0wUD4y41juHFOVMYiziPYr1ShSpQXdwp8FfaHrzI5hsr8UMe8D
-dzb9QzZ4bx3yZhiG3ahrSBh956thMTHrKTEwAfJIEXI4cuSVWQAaOJ4Em5SDFxQe
-d0E6Ui2nGh1SFGF7oyuEXyzqgRMWFNDFw9HLUNgXaO18Zfouw8+K0BgbfEWEcSi1
-JLQbyhCjz088gltrliQGPWDFAg9cHBKtJhuTzZkvuqK1CLEmBhtzP1zFiGBfOJc8
-v+aKjAwrPUNX11cXOCPxBv2qXMetxaovBem6AI2hvypCInXaVQfP+yOLubzlTDjS
-Y708SlY38hmS1uTwDpyLOn8AKkZ8jtx75g==
------END CERTIFICATE-----`
-
-	// ecdsaPrivateKeyWithParams is a ECDSA Private Key with included EC Parameters block
-	// openssl ecparam -name prime256v1 -genkey -out ecdsa256params.pem
-	ecdsaPrivateKeyWithParams = `-----BEGIN EC PARAMETERS-----
-BggqhkjOPQMBBw==
------END EC PARAMETERS-----
------BEGIN EC PRIVATE KEY-----
-MHcCAQEEIAwSOWQqlMTZNqNF7tgua812Jxib1DVOgb2pHHyIEyNNoAoGCCqGSM49
-AwEHoUQDQgAEyxYNrs6a6tsNCFNYn+l+JDUZ0PnUZbcsDgJn2O62D1se8M5iQ5rY
-iIv6RpxE3VHvlHEIvYgCZkG0jHszTUopBg==
------END EC PRIVATE KEY-----`
-
-	// ecdsaPrivateKey is a ECDSA Private Key in ASN.1 format
-	// openssl ecparam -name prime256v1 -genkey -noout -out ecdsa256.pem
-	ecdsaPrivateKey = `-----BEGIN EC PRIVATE KEY-----
-MHcCAQEEIP6Qw6dHDiLsSnLXUhQVTPE0fTQQrj3XSbiQAZPXnk5+oAoGCCqGSM49
-AwEHoUQDQgAEZZzi1u5f2/AEGFI/HYUhU+u6cTK1q2bbtE7r1JMK+/sQA5sNAp+7
-Vdc3psr1OaNzyTyuhTECyRdFKXm63cMnGg==
------END EC PRIVATE KEY-----`
-
-	// ecdsaPublicKey is a ECDSA Public Key in PEM encoded format
-	// openssl ec -in ecdsa256.pem -pubout -out ecdsa256pub.pem
-	ecdsaPublicKey = `-----BEGIN PUBLIC KEY-----
-MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEZZzi1u5f2/AEGFI/HYUhU+u6cTK1
-q2bbtE7r1JMK+/sQA5sNAp+7Vdc3psr1OaNzyTyuhTECyRdFKXm63cMnGg==
------END PUBLIC KEY-----`
-)
-
-func TestReadPrivateKey(t *testing.T) {
-	f, err := ioutil.TempFile("", "")
-	if err != nil {
-		t.Fatalf("error creating tmpfile: %v", err)
-	}
-	defer os.Remove(f.Name())
-
-	if _, err := PrivateKeyFromFile(f.Name()); err == nil {
-		t.Fatalf("Expected error reading key from empty file, got none")
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(rsaPrivateKey), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing private key to tmpfile: %v", err)
-	}
-	if _, err := PrivateKeyFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading private RSA key: %v", err)
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(ecdsaPrivateKey), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing private key to tmpfile: %v", err)
-	}
-	if _, err := PrivateKeyFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading private ECDSA key: %v", err)
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(ecdsaPrivateKeyWithParams), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing private key to tmpfile: %v", err)
-	}
-	if _, err := PrivateKeyFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading private ECDSA key with params: %v", err)
-	}
-}
-
-func TestReadPublicKeys(t *testing.T) {
-	f, err := ioutil.TempFile("", "")
-	if err != nil {
-		t.Fatalf("error creating tmpfile: %v", err)
-	}
-	defer os.Remove(f.Name())
-
-	if _, err := PublicKeysFromFile(f.Name()); err == nil {
-		t.Fatalf("Expected error reading keys from empty file, got none")
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(rsaPublicKey), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing public key to tmpfile: %v", err)
-	}
-	if keys, err := PublicKeysFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading RSA public key: %v", err)
-	} else if len(keys) != 1 {
-		t.Fatalf("expected 1 key, got %d", len(keys))
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(ecdsaPublicKey), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing public key to tmpfile: %v", err)
-	}
-	if keys, err := PublicKeysFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading ECDSA public key: %v", err)
-	} else if len(keys) != 1 {
-		t.Fatalf("expected 1 key, got %d", len(keys))
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(rsaPublicKey+"\n"+ecdsaPublicKey), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing public key to tmpfile: %v", err)
-	}
-	if keys, err := PublicKeysFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading combined RSA/ECDSA public key file: %v", err)
-	} else if len(keys) != 2 {
-		t.Fatalf("expected 2 keys, got %d", len(keys))
-	}
-
-	if err := ioutil.WriteFile(f.Name(), []byte(certificate), os.FileMode(0600)); err != nil {
-		t.Fatalf("error writing certificate to tmpfile: %v", err)
-	}
-	if keys, err := PublicKeysFromFile(f.Name()); err != nil {
-		t.Fatalf("error reading public key from certificate file: %v", err)
-	} else if len(keys) != 1 {
-		t.Fatalf("expected 1 keys, got %d", len(keys))
-	}
-
-}

vendor/k8s.io/client-go/util/flowcontrol/backoff_test.go

@@ -1,195 +0,0 @@
-/*
-Copyright 2015 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 flowcontrol
-
-import (
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/clock"
-)
-
-func TestSlowBackoff(t *testing.T) {
-	id := "_idSlow"
-	tc := clock.NewFakeClock(time.Now())
-	step := time.Second
-	maxDuration := 50 * step
-
-	b := NewFakeBackOff(step, maxDuration, tc)
-	cases := []time.Duration{0, 1, 2, 4, 8, 16, 32, 50, 50, 50}
-	for ix, c := range cases {
-		tc.Step(step)
-		w := b.Get(id)
-		if w != c*step {
-			t.Errorf("input: '%d': expected %s, got %s", ix, c*step, w)
-		}
-		b.Next(id, tc.Now())
-	}
-
-	//Now confirm that the Reset cancels backoff.
-	b.Next(id, tc.Now())
-	b.Reset(id)
-	if b.Get(id) != 0 {
-		t.Errorf("Reset didn't clear the backoff.")
-	}
-
-}
-
-func TestBackoffReset(t *testing.T) {
-	id := "_idReset"
-	tc := clock.NewFakeClock(time.Now())
-	step := time.Second
-	maxDuration := step * 5
-	b := NewFakeBackOff(step, maxDuration, tc)
-	startTime := tc.Now()
-
-	// get to backoff = maxDuration
-	for i := 0; i <= int(maxDuration/step); i++ {
-		tc.Step(step)
-		b.Next(id, tc.Now())
-	}
-
-	// backoff should be capped at maxDuration
-	if !b.IsInBackOffSince(id, tc.Now()) {
-		t.Errorf("expected to be in Backoff got %s", b.Get(id))
-	}
-
-	lastUpdate := tc.Now()
-	tc.Step(2*maxDuration + step) // time += 11s, 11 > 2*maxDuration
-	if b.IsInBackOffSince(id, lastUpdate) {
-		t.Errorf("expected to not be in Backoff after reset (start=%s, now=%s, lastUpdate=%s), got %s", startTime, tc.Now(), lastUpdate, b.Get(id))
-	}
-}
-
-func TestBackoffHightWaterMark(t *testing.T) {
-	id := "_idHiWaterMark"
-	tc := clock.NewFakeClock(time.Now())
-	step := time.Second
-	maxDuration := 5 * step
-	b := NewFakeBackOff(step, maxDuration, tc)
-
-	// get to backoff = maxDuration
-	for i := 0; i <= int(maxDuration/step); i++ {
-		tc.Step(step)
-		b.Next(id, tc.Now())
-	}
-
-	// backoff high watermark expires after 2*maxDuration
-	tc.Step(maxDuration + step)
-	b.Next(id, tc.Now())
-
-	if b.Get(id) != maxDuration {
-		t.Errorf("expected Backoff to stay at high watermark %s got %s", maxDuration, b.Get(id))
-	}
-}
-
-func TestBackoffGC(t *testing.T) {
-	id := "_idGC"
-	tc := clock.NewFakeClock(time.Now())
-	step := time.Second
-	maxDuration := 5 * step
-
-	b := NewFakeBackOff(step, maxDuration, tc)
-
-	for i := 0; i <= int(maxDuration/step); i++ {
-		tc.Step(step)
-		b.Next(id, tc.Now())
-	}
-	lastUpdate := tc.Now()
-	tc.Step(maxDuration + step)
-	b.GC()
-	_, found := b.perItemBackoff[id]
-	if !found {
-		t.Errorf("expected GC to skip entry, elapsed time=%s maxDuration=%s", tc.Now().Sub(lastUpdate), maxDuration)
-	}
-
-	tc.Step(maxDuration + step)
-	b.GC()
-	r, found := b.perItemBackoff[id]
-	if found {
-		t.Errorf("expected GC of entry after %s got entry %v", tc.Now().Sub(lastUpdate), r)
-	}
-}
-
-func TestIsInBackOffSinceUpdate(t *testing.T) {
-	id := "_idIsInBackOffSinceUpdate"
-	tc := clock.NewFakeClock(time.Now())
-	step := time.Second
-	maxDuration := 10 * step
-	b := NewFakeBackOff(step, maxDuration, tc)
-	startTime := tc.Now()
-
-	cases := []struct {
-		tick      time.Duration
-		inBackOff bool
-		value     int
-	}{
-		{tick: 0, inBackOff: false, value: 0},
-		{tick: 1, inBackOff: false, value: 1},
-		{tick: 2, inBackOff: true, value: 2},
-		{tick: 3, inBackOff: false, value: 2},
-		{tick: 4, inBackOff: true, value: 4},
-		{tick: 5, inBackOff: true, value: 4},
-		{tick: 6, inBackOff: true, value: 4},
-		{tick: 7, inBackOff: false, value: 4},
-		{tick: 8, inBackOff: true, value: 8},
-		{tick: 9, inBackOff: true, value: 8},
-		{tick: 10, inBackOff: true, value: 8},
-		{tick: 11, inBackOff: true, value: 8},
-		{tick: 12, inBackOff: true, value: 8},
-		{tick: 13, inBackOff: true, value: 8},
-		{tick: 14, inBackOff: true, value: 8},
-		{tick: 15, inBackOff: false, value: 8},
-		{tick: 16, inBackOff: true, value: 10},
-		{tick: 17, inBackOff: true, value: 10},
-		{tick: 18, inBackOff: true, value: 10},
-		{tick: 19, inBackOff: true, value: 10},
-		{tick: 20, inBackOff: true, value: 10},
-		{tick: 21, inBackOff: true, value: 10},
-		{tick: 22, inBackOff: true, value: 10},
-		{tick: 23, inBackOff: true, value: 10},
-		{tick: 24, inBackOff: true, value: 10},
-		{tick: 25, inBackOff: false, value: 10},
-		{tick: 26, inBackOff: true, value: 10},
-		{tick: 27, inBackOff: true, value: 10},
-		{tick: 28, inBackOff: true, value: 10},
-		{tick: 29, inBackOff: true, value: 10},
-		{tick: 30, inBackOff: true, value: 10},
-		{tick: 31, inBackOff: true, value: 10},
-		{tick: 32, inBackOff: true, value: 10},
-		{tick: 33, inBackOff: true, value: 10},
-		{tick: 34, inBackOff: true, value: 10},
-		{tick: 35, inBackOff: false, value: 10},
-		{tick: 56, inBackOff: false, value: 0},
-		{tick: 57, inBackOff: false, value: 1},
-	}
-
-	for _, c := range cases {
-		tc.SetTime(startTime.Add(c.tick * step))
-		if c.inBackOff != b.IsInBackOffSinceUpdate(id, tc.Now()) {
-			t.Errorf("expected IsInBackOffSinceUpdate %v got %v at tick %s", c.inBackOff, b.IsInBackOffSinceUpdate(id, tc.Now()), c.tick*step)
-		}
-
-		if c.inBackOff && (time.Duration(c.value)*step != b.Get(id)) {
-			t.Errorf("expected backoff value=%s got %s at tick %s", time.Duration(c.value)*step, b.Get(id), c.tick*step)
-		}
-
-		if !c.inBackOff {
-			b.Next(id, tc.Now())
-		}
-	}
-}

vendor/k8s.io/client-go/util/flowcontrol/throttle_test.go

@@ -1,153 +0,0 @@
-/*
-Copyright 2014 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 flowcontrol
-
-import (
-	"sync"
-	"testing"
-	"time"
-)
-
-func TestMultithreadedThrottling(t *testing.T) {
-	// Bucket with 100QPS and no burst
-	r := NewTokenBucketRateLimiter(100, 1)
-
-	// channel to collect 100 tokens
-	taken := make(chan bool, 100)
-
-	// Set up goroutines to hammer the throttler
-	startCh := make(chan bool)
-	endCh := make(chan bool)
-	for i := 0; i < 10; i++ {
-		go func() {
-			// wait for the starting signal
-			<-startCh
-			for {
-				// get a token
-				r.Accept()
-				select {
-				// try to add it to the taken channel
-				case taken <- true:
-					continue
-				// if taken is full, notify and return
-				default:
-					endCh <- true
-					return
-				}
-			}
-		}()
-	}
-
-	// record wall time
-	startTime := time.Now()
-	// take the initial capacity so all tokens are the result of refill
-	r.Accept()
-	// start the thundering herd
-	close(startCh)
-	// wait for the first signal that we collected 100 tokens
-	<-endCh
-	// record wall time
-	endTime := time.Now()
-
-	// tolerate a 1% clock change because these things happen
-	if duration := endTime.Sub(startTime); duration < (time.Second * 99 / 100) {
-		// We shouldn't be able to get 100 tokens out of the bucket in less than 1 second of wall clock time, no matter what
-		t.Errorf("Expected it to take at least 1 second to get 100 tokens, took %v", duration)
-	} else {
-		t.Logf("Took %v to get 100 tokens", duration)
-	}
-}
-
-func TestBasicThrottle(t *testing.T) {
-	r := NewTokenBucketRateLimiter(1, 3)
-	for i := 0; i < 3; i++ {
-		if !r.TryAccept() {
-			t.Error("unexpected false accept")
-		}
-	}
-	if r.TryAccept() {
-		t.Error("unexpected true accept")
-	}
-}
-
-func TestIncrementThrottle(t *testing.T) {
-	r := NewTokenBucketRateLimiter(1, 1)
-	if !r.TryAccept() {
-		t.Error("unexpected false accept")
-	}
-	if r.TryAccept() {
-		t.Error("unexpected true accept")
-	}
-
-	// Allow to refill
-	time.Sleep(2 * time.Second)
-
-	if !r.TryAccept() {
-		t.Error("unexpected false accept")
-	}
-}
-
-func TestThrottle(t *testing.T) {
-	r := NewTokenBucketRateLimiter(10, 5)
-
-	// Should consume 5 tokens immediately, then
-	// the remaining 11 should take at least 1 second (0.1s each)
-	expectedFinish := time.Now().Add(time.Second * 1)
-	for i := 0; i < 16; i++ {
-		r.Accept()
-	}
-	if time.Now().Before(expectedFinish) {
-		t.Error("rate limit was not respected, finished too early")
-	}
-}
-
-func TestAlwaysFake(t *testing.T) {
-	rl := NewFakeAlwaysRateLimiter()
-	if !rl.TryAccept() {
-		t.Error("TryAccept in AlwaysFake should return true.")
-	}
-	// If this will block the test will timeout
-	rl.Accept()
-}
-
-func TestNeverFake(t *testing.T) {
-	rl := NewFakeNeverRateLimiter()
-	if rl.TryAccept() {
-		t.Error("TryAccept in NeverFake should return false.")
-	}
-
-	finished := false
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-	go func() {
-		rl.Accept()
-		finished = true
-		wg.Done()
-	}()
-
-	// Wait some time to make sure it never finished.
-	time.Sleep(time.Second)
-	if finished {
-		t.Error("Accept should block forever in NeverFake.")
-	}
-
-	rl.Stop()
-	wg.Wait()
-	if !finished {
-		t.Error("Stop should make Accept unblock in NeverFake.")
-	}
-}

vendor/k8s.io/client-go/util/integer/integer_test.go

@@ -1,244 +0,0 @@
-/*
-Copyright 2016 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 integer
-
-import "testing"
-
-func TestIntMax(t *testing.T) {
-	tests := []struct {
-		nums        []int
-		expectedMax int
-	}{
-		{
-			nums:        []int{-1, 0},
-			expectedMax: 0,
-		},
-		{
-			nums:        []int{-1, -2},
-			expectedMax: -1,
-		},
-		{
-			nums:        []int{0, 1},
-			expectedMax: 1,
-		},
-		{
-			nums:        []int{1, 2},
-			expectedMax: 2,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if max := IntMax(test.nums[0], test.nums[1]); max != test.expectedMax {
-			t.Errorf("expected %v,  got %v", test.expectedMax, max)
-		}
-	}
-}
-
-func TestIntMin(t *testing.T) {
-	tests := []struct {
-		nums        []int
-		expectedMin int
-	}{
-		{
-			nums:        []int{-1, 0},
-			expectedMin: -1,
-		},
-		{
-			nums:        []int{-1, -2},
-			expectedMin: -2,
-		},
-		{
-			nums:        []int{0, 1},
-			expectedMin: 0,
-		},
-		{
-			nums:        []int{1, 2},
-			expectedMin: 1,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if min := IntMin(test.nums[0], test.nums[1]); min != test.expectedMin {
-			t.Errorf("expected %v,  got %v", test.expectedMin, min)
-		}
-	}
-}
-
-func TestInt32Max(t *testing.T) {
-	tests := []struct {
-		nums        []int32
-		expectedMax int32
-	}{
-		{
-			nums:        []int32{-1, 0},
-			expectedMax: 0,
-		},
-		{
-			nums:        []int32{-1, -2},
-			expectedMax: -1,
-		},
-		{
-			nums:        []int32{0, 1},
-			expectedMax: 1,
-		},
-		{
-			nums:        []int32{1, 2},
-			expectedMax: 2,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if max := Int32Max(test.nums[0], test.nums[1]); max != test.expectedMax {
-			t.Errorf("expected %v,  got %v", test.expectedMax, max)
-		}
-	}
-}
-
-func TestInt32Min(t *testing.T) {
-	tests := []struct {
-		nums        []int32
-		expectedMin int32
-	}{
-		{
-			nums:        []int32{-1, 0},
-			expectedMin: -1,
-		},
-		{
-			nums:        []int32{-1, -2},
-			expectedMin: -2,
-		},
-		{
-			nums:        []int32{0, 1},
-			expectedMin: 0,
-		},
-		{
-			nums:        []int32{1, 2},
-			expectedMin: 1,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if min := Int32Min(test.nums[0], test.nums[1]); min != test.expectedMin {
-			t.Errorf("expected %v,  got %v", test.expectedMin, min)
-		}
-	}
-}
-
-func TestInt64Max(t *testing.T) {
-	tests := []struct {
-		nums        []int64
-		expectedMax int64
-	}{
-		{
-			nums:        []int64{-1, 0},
-			expectedMax: 0,
-		},
-		{
-			nums:        []int64{-1, -2},
-			expectedMax: -1,
-		},
-		{
-			nums:        []int64{0, 1},
-			expectedMax: 1,
-		},
-		{
-			nums:        []int64{1, 2},
-			expectedMax: 2,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if max := Int64Max(test.nums[0], test.nums[1]); max != test.expectedMax {
-			t.Errorf("expected %v,  got %v", test.expectedMax, max)
-		}
-	}
-}
-
-func TestInt64Min(t *testing.T) {
-	tests := []struct {
-		nums        []int64
-		expectedMin int64
-	}{
-		{
-			nums:        []int64{-1, 0},
-			expectedMin: -1,
-		},
-		{
-			nums:        []int64{-1, -2},
-			expectedMin: -2,
-		},
-		{
-			nums:        []int64{0, 1},
-			expectedMin: 0,
-		},
-		{
-			nums:        []int64{1, 2},
-			expectedMin: 1,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if min := Int64Min(test.nums[0], test.nums[1]); min != test.expectedMin {
-			t.Errorf("expected %v,  got %v", test.expectedMin, min)
-		}
-	}
-}
-
-func TestRoundToInt32(t *testing.T) {
-	tests := []struct {
-		num float64
-		exp int32
-	}{
-		{
-			num: 5.5,
-			exp: 6,
-		},
-		{
-			num: -3.7,
-			exp: -4,
-		},
-		{
-			num: 3.49,
-			exp: 3,
-		},
-		{
-			num: -7.9,
-			exp: -8,
-		},
-		{
-			num: -4.499999,
-			exp: -4,
-		},
-		{
-			num: 0,
-			exp: 0,
-		},
-	}
-
-	for i, test := range tests {
-		t.Logf("executing scenario %d", i)
-		if got := RoundToInt32(test.num); got != test.exp {
-			t.Errorf("expected %d, got %d", test.exp, got)
-		}
-	}
-}

vendor/k8s.io/client-go/util/jsonpath/jsonpath_test.go

@@ -1,371 +0,0 @@
-/*
-Copyright 2015 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 jsonpath
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"reflect"
-	"sort"
-	"strings"
-	"testing"
-)
-
-type jsonpathTest struct {
-	name        string
-	template    string
-	input       interface{}
-	expect      string
-	expectError bool
-}
-
-func testJSONPath(tests []jsonpathTest, allowMissingKeys bool, t *testing.T) {
-	for _, test := range tests {
-		j := New(test.name)
-		j.AllowMissingKeys(allowMissingKeys)
-		err := j.Parse(test.template)
-		if err != nil {
-			t.Errorf("in %s, parse %s error %v", test.name, test.template, err)
-		}
-		buf := new(bytes.Buffer)
-		err = j.Execute(buf, test.input)
-		if test.expectError {
-			if test.expectError && err == nil {
-				t.Errorf("in %s, expected execute error", test.name)
-			}
-			continue
-		} else if err != nil {
-			t.Errorf("in %s, execute error %v", test.name, err)
-		}
-		out := buf.String()
-		if out != test.expect {
-			t.Errorf(`in %s, expect to get "%s", got "%s"`, test.name, test.expect, out)
-		}
-	}
-}
-
-// testJSONPathSortOutput test cases related to map, the results may print in random order
-func testJSONPathSortOutput(tests []jsonpathTest, t *testing.T) {
-	for _, test := range tests {
-		j := New(test.name)
-		err := j.Parse(test.template)
-		if err != nil {
-			t.Errorf("in %s, parse %s error %v", test.name, test.template, err)
-		}
-		buf := new(bytes.Buffer)
-		err = j.Execute(buf, test.input)
-		if err != nil {
-			t.Errorf("in %s, execute error %v", test.name, err)
-		}
-		out := buf.String()
-		//since map is visited in random order, we need to sort the results.
-		sortedOut := strings.Fields(out)
-		sort.Strings(sortedOut)
-		sortedExpect := strings.Fields(test.expect)
-		sort.Strings(sortedExpect)
-		if !reflect.DeepEqual(sortedOut, sortedExpect) {
-			t.Errorf(`in %s, expect to get "%s", got "%s"`, test.name, test.expect, out)
-		}
-	}
-}
-
-func testFailJSONPath(tests []jsonpathTest, t *testing.T) {
-	for _, test := range tests {
-		j := New(test.name)
-		err := j.Parse(test.template)
-		if err != nil {
-			t.Errorf("in %s, parse %s error %v", test.name, test.template, err)
-		}
-		buf := new(bytes.Buffer)
-		err = j.Execute(buf, test.input)
-		var out string
-		if err == nil {
-			out = "nil"
-		} else {
-			out = err.Error()
-		}
-		if out != test.expect {
-			t.Errorf("in %s, expect to get error %q, got %q", test.name, test.expect, out)
-		}
-	}
-}
-
-type book struct {
-	Category string
-	Author   string
-	Title    string
-	Price    float32
-}
-
-func (b book) String() string {
-	return fmt.Sprintf("{Category: %s, Author: %s, Title: %s, Price: %v}", b.Category, b.Author, b.Title, b.Price)
-}
-
-type bicycle struct {
-	Color string
-	Price float32
-	IsNew bool
-}
-
-type empName string
-type job string
-type store struct {
-	Book      []book
-	Bicycle   []bicycle
-	Name      string
-	Labels    map[string]int
-	Employees map[empName]job
-}
-
-func TestStructInput(t *testing.T) {
-
-	storeData := store{
-		Name: "jsonpath",
-		Book: []book{
-			{"reference", "Nigel Rees", "Sayings of the Centurey", 8.95},
-			{"fiction", "Evelyn Waugh", "Sword of Honour", 12.99},
-			{"fiction", "Herman Melville", "Moby Dick", 8.99},
-		},
-		Bicycle: []bicycle{
-			{"red", 19.95, true},
-			{"green", 20.01, false},
-		},
-		Labels: map[string]int{
-			"engieer":  10,
-			"web/html": 15,
-			"k8s-app":  20,
-		},
-		Employees: map[empName]job{
-			"jason": "manager",
-			"dan":   "clerk",
-		},
-	}
-
-	storeTests := []jsonpathTest{
-		{"plain", "hello jsonpath", nil, "hello jsonpath", false},
-		{"recursive", "{..}", []int{1, 2, 3}, "[1 2 3]", false},
-		{"filter", "{[?(@<5)]}", []int{2, 6, 3, 7}, "2 3", false},
-		{"quote", `{"{"}`, nil, "{", false},
-		{"union", "{[1,3,4]}", []int{0, 1, 2, 3, 4}, "1 3 4", false},
-		{"array", "{[0:2]}", []string{"Monday", "Tudesday"}, "Monday Tudesday", false},
-		{"variable", "hello {.Name}", storeData, "hello jsonpath", false},
-		{"dict/", "{$.Labels.web/html}", storeData, "15", false},
-		{"dict/", "{$.Employees.jason}", storeData, "manager", false},
-		{"dict/", "{$.Employees.dan}", storeData, "clerk", false},
-		{"dict-", "{.Labels.k8s-app}", storeData, "20", false},
-		{"nest", "{.Bicycle[*].Color}", storeData, "red green", false},
-		{"allarray", "{.Book[*].Author}", storeData, "Nigel Rees Evelyn Waugh Herman Melville", false},
-		{"allfileds", "{.Bicycle.*}", storeData, "{red 19.95 true} {green 20.01 false}", false},
-		{"recurfileds", "{..Price}", storeData, "8.95 12.99 8.99 19.95 20.01", false},
-		{"lastarray", "{.Book[-1:]}", storeData,
-			"{Category: fiction, Author: Herman Melville, Title: Moby Dick, Price: 8.99}", false},
-		{"recurarray", "{..Book[2]}", storeData,
-			"{Category: fiction, Author: Herman Melville, Title: Moby Dick, Price: 8.99}", false},
-		{"bool", "{.Bicycle[?(@.IsNew==true)]}", storeData, "{red 19.95 true}", false},
-	}
-	testJSONPath(storeTests, false, t)
-
-	missingKeyTests := []jsonpathTest{
-		{"nonexistent field", "{.hello}", storeData, "", false},
-	}
-	testJSONPath(missingKeyTests, true, t)
-
-	failStoreTests := []jsonpathTest{
-		{"invalid identifier", "{hello}", storeData, "unrecognized identifier hello", false},
-		{"nonexistent field", "{.hello}", storeData, "hello is not found", false},
-		{"invalid array", "{.Labels[0]}", storeData, "map[string]int is not array or slice", false},
-		{"invalid filter operator", "{.Book[?(@.Price<>10)]}", storeData, "unrecognized filter operator <>", false},
-		{"redundant end", "{range .Labels.*}{@}{end}{end}", storeData, "not in range, nothing to end", false},
-	}
-	testFailJSONPath(failStoreTests, t)
-}
-
-func TestJSONInput(t *testing.T) {
-	var pointsJSON = []byte(`[
-		{"id": "i1", "x":4, "y":-5},
-		{"id": "i2", "x":-2, "y":-5, "z":1},
-		{"id": "i3", "x":  8, "y":  3 },
-		{"id": "i4", "x": -6, "y": -1 },
-		{"id": "i5", "x":  0, "y":  2, "z": 1 },
-		{"id": "i6", "x":  1, "y":  4 }
-	]`)
-	var pointsData interface{}
-	err := json.Unmarshal(pointsJSON, &pointsData)
-	if err != nil {
-		t.Error(err)
-	}
-	pointsTests := []jsonpathTest{
-		{"exists filter", "{[?(@.z)].id}", pointsData, "i2 i5", false},
-		{"bracket key", "{[0]['id']}", pointsData, "i1", false},
-	}
-	testJSONPath(pointsTests, false, t)
-}
-
-// TestKubernetes tests some use cases from kubernetes
-func TestKubernetes(t *testing.T) {
-	var input = []byte(`{
-	  "kind": "List",
-	  "items":[
-		{
-		  "kind":"None",
-		  "metadata":{
-		    "name":"127.0.0.1",
-			"labels":{
-			  "kubernetes.io/hostname":"127.0.0.1"
-			}
-		  },
-		  "status":{
-			"capacity":{"cpu":"4"},
-			"ready": true,
-			"addresses":[{"type": "LegacyHostIP", "address":"127.0.0.1"}]
-		  }
-		},
-		{
-		  "kind":"None",
-		  "metadata":{
-			"name":"127.0.0.2",
-			"labels":{
-			  "kubernetes.io/hostname":"127.0.0.2"
-			}
-		  },
-		  "status":{
-			"capacity":{"cpu":"8"},
-			"ready": false,
-			"addresses":[
-			  {"type": "LegacyHostIP", "address":"127.0.0.2"},
-			  {"type": "another", "address":"127.0.0.3"}
-			]
-		  }
-		}
-	  ],
-	  "users":[
-	    {
-	      "name": "myself",
-	      "user": {}
-	    },
-	    {
-	      "name": "e2e",
-	      "user": {"username": "admin", "password": "secret"}
-	  	}
-	  ]
-	}`)
-	var nodesData interface{}
-	err := json.Unmarshal(input, &nodesData)
-	if err != nil {
-		t.Error(err)
-	}
-
-	nodesTests := []jsonpathTest{
-		{"range item", `{range .items[*]}{.metadata.name}, {end}{.kind}`, nodesData, "127.0.0.1, 127.0.0.2, List", false},
-		{"range item with quote", `{range .items[*]}{.metadata.name}{"\t"}{end}`, nodesData, "127.0.0.1\t127.0.0.2\t", false},
-		{"range addresss", `{.items[*].status.addresses[*].address}`, nodesData,
-			"127.0.0.1 127.0.0.2 127.0.0.3", false},
-		{"double range", `{range .items[*]}{range .status.addresses[*]}{.address}, {end}{end}`, nodesData,
-			"127.0.0.1, 127.0.0.2, 127.0.0.3, ", false},
-		{"item name", `{.items[*].metadata.name}`, nodesData, "127.0.0.1 127.0.0.2", false},
-		{"union nodes capacity", `{.items[*]['metadata.name', 'status.capacity']}`, nodesData,
-			"127.0.0.1 127.0.0.2 map[cpu:4] map[cpu:8]", false},
-		{"range nodes capacity", `{range .items[*]}[{.metadata.name}, {.status.capacity}] {end}`, nodesData,
-			"[127.0.0.1, map[cpu:4]] [127.0.0.2, map[cpu:8]] ", false},
-		{"user password", `{.users[?(@.name=="e2e")].user.password}`, &nodesData, "secret", false},
-		{"hostname", `{.items[0].metadata.labels.kubernetes\.io/hostname}`, &nodesData, "127.0.0.1", false},
-		{"hostname filter", `{.items[?(@.metadata.labels.kubernetes\.io/hostname=="127.0.0.1")].kind}`, &nodesData, "None", false},
-		{"bool item", `{.items[?(@..ready==true)].metadata.name}`, &nodesData, "127.0.0.1", false},
-	}
-	testJSONPath(nodesTests, false, t)
-
-	randomPrintOrderTests := []jsonpathTest{
-		{"recursive name", "{..name}", nodesData, `127.0.0.1 127.0.0.2 myself e2e`, false},
-	}
-	testJSONPathSortOutput(randomPrintOrderTests, t)
-}
-
-func TestFilterPartialMatchesSometimesMissingAnnotations(t *testing.T) {
-	// for https://issues.k8s.io/45546
-	var input = []byte(`{
-		"kind": "List",
-		"items": [
-			{
-				"kind": "Pod",
-				"metadata": {
-					"name": "pod1",
-					"annotations": {
-						"color": "blue"
-					}
-				}
-			},
-			{
-				"kind": "Pod",
-				"metadata": {
-					"name": "pod2"
-				}
-			},
-			{
-				"kind": "Pod",
-				"metadata": {
-					"name": "pod3",
-					"annotations": {
-						"color": "green"
-					}
-				}
-			},
-			{
-				"kind": "Pod",
-				"metadata": {
-					"name": "pod4",
-					"annotations": {
-						"color": "blue"
-					}
-				}
-			}
-		]
-	}`)
-	var data interface{}
-	err := json.Unmarshal(input, &data)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	testJSONPath(
-		[]jsonpathTest{
-			{
-				"filter, should only match a subset, some items don't have annotations, tolerate missing items",
-				`{.items[?(@.metadata.annotations.color=="blue")].metadata.name}`,
-				data,
-				"pod1 pod4",
-				false, // expect no error
-			},
-		},
-		true, // allow missing keys
-		t,
-	)
-
-	testJSONPath(
-		[]jsonpathTest{
-			{
-				"filter, should only match a subset, some items don't have annotations, error on missing items",
-				`{.items[?(@.metadata.annotations.color=="blue")].metadata.name}`,
-				data,
-				"",
-				true, // expect an error
-			},
-		},
-		false, // don't allow missing keys
-		t,
-	)
-}

vendor/k8s.io/client-go/util/jsonpath/parser_test.go

@@ -1,152 +0,0 @@
-/*
-Copyright 2015 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 jsonpath
-
-import (
-	"testing"
-)
-
-type parserTest struct {
-	name        string
-	text        string
-	nodes       []Node
-	shouldError bool
-}
-
-var parserTests = []parserTest{
-	{"plain", `hello jsonpath`, []Node{newText("hello jsonpath")}, false},
-	{"variable", `hello {.jsonpath}`,
-		[]Node{newText("hello "), newList(), newField("jsonpath")}, false},
-	{"arrayfiled", `hello {['jsonpath']}`,
-		[]Node{newText("hello "), newList(), newField("jsonpath")}, false},
-	{"quote", `{"{"}`, []Node{newList(), newText("{")}, false},
-	{"array", `{[1:3]}`, []Node{newList(),
-		newArray([3]ParamsEntry{{1, true}, {3, true}, {0, false}})}, false},
-	{"allarray", `{.book[*].author}`,
-		[]Node{newList(), newField("book"),
-			newArray([3]ParamsEntry{{0, false}, {0, false}, {0, false}}), newField("author")}, false},
-	{"wildcard", `{.bicycle.*}`,
-		[]Node{newList(), newField("bicycle"), newWildcard()}, false},
-	{"filter", `{[?(@.price<3)]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "<"),
-			newList(), newField("price"), newList(), newInt(3)}, false},
-	{"recursive", `{..}`, []Node{newList(), newRecursive()}, false},
-	{"recurField", `{..price}`,
-		[]Node{newList(), newRecursive(), newField("price")}, false},
-	{"arraydict", `{['book.price']}`, []Node{newList(),
-		newField("book"), newField("price"),
-	}, false},
-	{"union", `{['bicycle.price', 3, 'book.price']}`, []Node{newList(), newUnion([]*ListNode{}),
-		newList(), newField("bicycle"), newField("price"),
-		newList(), newArray([3]ParamsEntry{{3, true}, {4, true}, {0, false}}),
-		newList(), newField("book"), newField("price"),
-	}, false},
-	{"range", `{range .items}{.name},{end}`, []Node{
-		newList(), newIdentifier("range"), newField("items"),
-		newList(), newField("name"), newText(","),
-		newList(), newIdentifier("end"),
-	}, false},
-	{"malformat input", `{\\\}`, []Node{}, true},
-	{"paired parentheses in quotes", `{[?(@.status.nodeInfo.osImage == "()")]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("()")}, false},
-	{"paired parentheses in double quotes and with double quotes escape", `{[?(@.status.nodeInfo.osImage == "(\"\")")]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("(\"\")")}, false},
-	{"unregular parentheses in double quotes", `{[?(@.test == "())(")]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("test"), newList(), newText("())(")}, false},
-	{"plain text in single quotes", `{[?(@.status.nodeInfo.osImage == 'Linux')]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("Linux")}, false},
-	{"test filter suffix", `{[?(@.status.nodeInfo.osImage == "{[()]}")]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("{[()]}")}, false},
-	{"double inside single", `{[?(@.status.nodeInfo.osImage == "''")]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("''")}, false},
-	{"single inside double", `{[?(@.status.nodeInfo.osImage == '""')]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("\"\"")}, false},
-	{"single containing escaped single", `{[?(@.status.nodeInfo.osImage == '\\\'')]}`,
-		[]Node{newList(), newFilter(newList(), newList(), "=="), newList(), newField("status"), newField("nodeInfo"), newField("osImage"), newList(), newText("\\'")}, false},
-}
-
-func collectNode(nodes []Node, cur Node) []Node {
-	nodes = append(nodes, cur)
-	switch cur.Type() {
-	case NodeList:
-		for _, node := range cur.(*ListNode).Nodes {
-			nodes = collectNode(nodes, node)
-		}
-	case NodeFilter:
-		nodes = collectNode(nodes, cur.(*FilterNode).Left)
-		nodes = collectNode(nodes, cur.(*FilterNode).Right)
-	case NodeUnion:
-		for _, node := range cur.(*UnionNode).Nodes {
-			nodes = collectNode(nodes, node)
-		}
-	}
-	return nodes
-}
-
-func TestParser(t *testing.T) {
-	for _, test := range parserTests {
-		parser, err := Parse(test.name, test.text)
-		if test.shouldError {
-			if err == nil {
-				t.Errorf("unexpected non-error when parsing %s", test.name)
-			}
-			continue
-		}
-		if err != nil {
-			t.Errorf("parse %s error %v", test.name, err)
-		}
-		result := collectNode([]Node{}, parser.Root)[1:]
-		if len(result) != len(test.nodes) {
-			t.Errorf("in %s, expect to get %d nodes, got %d nodes", test.name, len(test.nodes), len(result))
-			t.Error(result)
-		}
-		for i, expect := range test.nodes {
-			if result[i].String() != expect.String() {
-				t.Errorf("in %s, %dth node, expect %v, got %v", test.name, i, expect, result[i])
-			}
-		}
-	}
-}
-
-type failParserTest struct {
-	name string
-	text string
-	err  string
-}
-
-func TestFailParser(t *testing.T) {
-	failParserTests := []failParserTest{
-		{"unclosed action", "{.hello", "unclosed action"},
-		{"unrecognized character", "{*}", "unrecognized character in action: U+002A '*'"},
-		{"invalid number", "{+12.3.0}", "cannot parse number +12.3.0"},
-		{"unterminated array", "{[1}", "unterminated array"},
-		{"invalid index", "{[::-1]}", "invalid array index ::-1"},
-		{"unterminated filter", "{[?(.price]}", "unterminated filter"},
-	}
-	for _, test := range failParserTests {
-		_, err := Parse(test.name, test.text)
-		var out string
-		if err == nil {
-			out = "nil"
-		} else {
-			out = err.Error()
-		}
-		if out != test.err {
-			t.Errorf("in %s, expect to get error %v, got %v", test.name, test.err, out)
-		}
-	}
-}

vendor/k8s.io/client-go/util/retry/util_test.go

@@ -1,71 +0,0 @@
-/*
-Copyright 2016 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 retry
-
-import (
-	"fmt"
-	"testing"
-
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/util/wait"
-)
-
-func TestRetryOnConflict(t *testing.T) {
-	opts := wait.Backoff{Factor: 1.0, Steps: 3}
-	conflictErr := errors.NewConflict(schema.GroupResource{Resource: "test"}, "other", nil)
-
-	// never returns
-	err := RetryOnConflict(opts, func() error {
-		return conflictErr
-	})
-	if err != conflictErr {
-		t.Errorf("unexpected error: %v", err)
-	}
-
-	// returns immediately
-	i := 0
-	err = RetryOnConflict(opts, func() error {
-		i++
-		return nil
-	})
-	if err != nil || i != 1 {
-		t.Errorf("unexpected error: %v", err)
-	}
-
-	// returns immediately on error
-	testErr := fmt.Errorf("some other error")
-	err = RetryOnConflict(opts, func() error {
-		return testErr
-	})
-	if err != testErr {
-		t.Errorf("unexpected error: %v", err)
-	}
-
-	// keeps retrying
-	i = 0
-	err = RetryOnConflict(opts, func() error {
-		if i < 2 {
-			i++
-			return errors.NewConflict(schema.GroupResource{Resource: "test"}, "other", nil)
-		}
-		return nil
-	})
-	if err != nil || i != 2 {
-		t.Errorf("unexpected error: %v", err)
-	}
-}

vendor/k8s.io/client-go/util/workqueue/default_rate_limiters_test.go

@@ -1,184 +0,0 @@
-/*
-Copyright 2016 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 workqueue
-
-import (
-	"testing"
-	"time"
-)
-
-func TestItemExponentialFailureRateLimiter(t *testing.T) {
-	limiter := NewItemExponentialFailureRateLimiter(1*time.Millisecond, 1*time.Second)
-
-	if e, a := 1*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 4*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 8*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 16*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	if e, a := 1*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2, limiter.NumRequeues("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	limiter.Forget("one")
-	if e, a := 0, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 1*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-}
-
-func TestItemExponentialFailureRateLimiterOverFlow(t *testing.T) {
-	limiter := NewItemExponentialFailureRateLimiter(1*time.Millisecond, 1000*time.Second)
-	for i := 0; i < 5; i++ {
-		limiter.When("one")
-	}
-	if e, a := 32*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	for i := 0; i < 1000; i++ {
-		limiter.When("overflow1")
-	}
-	if e, a := 1000*time.Second, limiter.When("overflow1"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	limiter = NewItemExponentialFailureRateLimiter(1*time.Minute, 1000*time.Hour)
-	for i := 0; i < 2; i++ {
-		limiter.When("two")
-	}
-	if e, a := 4*time.Minute, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	for i := 0; i < 1000; i++ {
-		limiter.When("overflow2")
-	}
-	if e, a := 1000*time.Hour, limiter.When("overflow2"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-}
-
-func TestItemFastSlowRateLimiter(t *testing.T) {
-	limiter := NewItemFastSlowRateLimiter(5*time.Millisecond, 10*time.Second, 3)
-
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 10*time.Second, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 10*time.Second, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	if e, a := 5*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2, limiter.NumRequeues("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	limiter.Forget("one")
-	if e, a := 0, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-}
-
-func TestMaxOfRateLimiter(t *testing.T) {
-	limiter := NewMaxOfRateLimiter(
-		NewItemFastSlowRateLimiter(5*time.Millisecond, 3*time.Second, 3),
-		NewItemExponentialFailureRateLimiter(1*time.Millisecond, 1*time.Second),
-	)
-
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 3*time.Second, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 3*time.Second, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	if e, a := 5*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2, limiter.NumRequeues("two"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	limiter.Forget("one")
-	if e, a := 0, limiter.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 5*time.Millisecond, limiter.When("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-}

vendor/k8s.io/client-go/util/workqueue/delaying_queue_test.go

@@ -1,255 +0,0 @@
-/*
-Copyright 2016 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 workqueue
-
-import (
-	"fmt"
-	"math/rand"
-	"reflect"
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/clock"
-	"k8s.io/apimachinery/pkg/util/wait"
-)
-
-func TestSimpleQueue(t *testing.T) {
-	fakeClock := clock.NewFakeClock(time.Now())
-	q := newDelayingQueue(fakeClock, "")
-
-	first := "foo"
-
-	q.AddAfter(first, 50*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	fakeClock.Step(60 * time.Millisecond)
-
-	if err := waitForAdded(q, 1); err != nil {
-		t.Errorf("should have added")
-	}
-	item, _ := q.Get()
-	q.Done(item)
-
-	// step past the next heartbeat
-	fakeClock.Step(10 * time.Second)
-
-	err := wait.Poll(1*time.Millisecond, 30*time.Millisecond, func() (done bool, err error) {
-		if q.Len() > 0 {
-			return false, fmt.Errorf("added to queue")
-		}
-
-		return false, nil
-	})
-	if err != wait.ErrWaitTimeout {
-		t.Errorf("expected timeout, got: %v", err)
-	}
-
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-}
-
-func TestDeduping(t *testing.T) {
-	fakeClock := clock.NewFakeClock(time.Now())
-	q := newDelayingQueue(fakeClock, "")
-
-	first := "foo"
-
-	q.AddAfter(first, 50*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	q.AddAfter(first, 70*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	// step past the first block, we should receive now
-	fakeClock.Step(60 * time.Millisecond)
-	if err := waitForAdded(q, 1); err != nil {
-		t.Errorf("should have added")
-	}
-	item, _ := q.Get()
-	q.Done(item)
-
-	// step past the second add
-	fakeClock.Step(20 * time.Millisecond)
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	// test again, but this time the earlier should override
-	q.AddAfter(first, 50*time.Millisecond)
-	q.AddAfter(first, 30*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	fakeClock.Step(40 * time.Millisecond)
-	if err := waitForAdded(q, 1); err != nil {
-		t.Errorf("should have added")
-	}
-	item, _ = q.Get()
-	q.Done(item)
-
-	// step past the second add
-	fakeClock.Step(20 * time.Millisecond)
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-}
-
-func TestAddTwoFireEarly(t *testing.T) {
-	fakeClock := clock.NewFakeClock(time.Now())
-	q := newDelayingQueue(fakeClock, "")
-
-	first := "foo"
-	second := "bar"
-	third := "baz"
-
-	q.AddAfter(first, 1*time.Second)
-	q.AddAfter(second, 50*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	fakeClock.Step(60 * time.Millisecond)
-
-	if err := waitForAdded(q, 1); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	item, _ := q.Get()
-	if !reflect.DeepEqual(item, second) {
-		t.Errorf("expected %v, got %v", second, item)
-	}
-
-	q.AddAfter(third, 2*time.Second)
-
-	fakeClock.Step(1 * time.Second)
-	if err := waitForAdded(q, 1); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	item, _ = q.Get()
-	if !reflect.DeepEqual(item, first) {
-		t.Errorf("expected %v, got %v", first, item)
-	}
-
-	fakeClock.Step(2 * time.Second)
-	if err := waitForAdded(q, 1); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	item, _ = q.Get()
-	if !reflect.DeepEqual(item, third) {
-		t.Errorf("expected %v, got %v", third, item)
-	}
-}
-
-func TestCopyShifting(t *testing.T) {
-	fakeClock := clock.NewFakeClock(time.Now())
-	q := newDelayingQueue(fakeClock, "")
-
-	first := "foo"
-	second := "bar"
-	third := "baz"
-
-	q.AddAfter(first, 1*time.Second)
-	q.AddAfter(second, 500*time.Millisecond)
-	q.AddAfter(third, 250*time.Millisecond)
-	if err := waitForWaitingQueueToFill(q); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-
-	if q.Len() != 0 {
-		t.Errorf("should not have added")
-	}
-
-	fakeClock.Step(2 * time.Second)
-
-	if err := waitForAdded(q, 3); err != nil {
-		t.Fatalf("unexpected err: %v", err)
-	}
-	actualFirst, _ := q.Get()
-	if !reflect.DeepEqual(actualFirst, third) {
-		t.Errorf("expected %v, got %v", third, actualFirst)
-	}
-	actualSecond, _ := q.Get()
-	if !reflect.DeepEqual(actualSecond, second) {
-		t.Errorf("expected %v, got %v", second, actualSecond)
-	}
-	actualThird, _ := q.Get()
-	if !reflect.DeepEqual(actualThird, first) {
-		t.Errorf("expected %v, got %v", first, actualThird)
-	}
-}
-
-func BenchmarkDelayingQueue_AddAfter(b *testing.B) {
-	r := rand.New(rand.NewSource(time.Now().Unix()))
-
-	fakeClock := clock.NewFakeClock(time.Now())
-	q := newDelayingQueue(fakeClock, "")
-
-	// Add items
-	for n := 0; n < b.N; n++ {
-		data := fmt.Sprintf("%d", n)
-		q.AddAfter(data, time.Duration(r.Int63n(int64(10*time.Minute))))
-	}
-
-	// Exercise item removal as well
-	fakeClock.Step(11 * time.Minute)
-	for n := 0; n < b.N; n++ {
-		_, _ = q.Get()
-	}
-}
-
-func waitForAdded(q DelayingInterface, depth int) error {
-	return wait.Poll(1*time.Millisecond, 10*time.Second, func() (done bool, err error) {
-		if q.Len() == depth {
-			return true, nil
-		}
-
-		return false, nil
-	})
-}
-
-func waitForWaitingQueueToFill(q DelayingInterface) error {
-	return wait.Poll(1*time.Millisecond, 10*time.Second, func() (done bool, err error) {
-		if len(q.(*delayingType).waitingForAddCh) == 0 {
-			return true, nil
-		}
-
-		return false, nil
-	})
-}

vendor/k8s.io/client-go/util/workqueue/queue_test.go

@@ -1,161 +0,0 @@
-/*
-Copyright 2015 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 workqueue_test
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"k8s.io/client-go/util/workqueue"
-)
-
-func TestBasic(t *testing.T) {
-	// If something is seriously wrong this test will never complete.
-	q := workqueue.New()
-
-	// Start producers
-	const producers = 50
-	producerWG := sync.WaitGroup{}
-	producerWG.Add(producers)
-	for i := 0; i < producers; i++ {
-		go func(i int) {
-			defer producerWG.Done()
-			for j := 0; j < 50; j++ {
-				q.Add(i)
-				time.Sleep(time.Millisecond)
-			}
-		}(i)
-	}
-
-	// Start consumers
-	const consumers = 10
-	consumerWG := sync.WaitGroup{}
-	consumerWG.Add(consumers)
-	for i := 0; i < consumers; i++ {
-		go func(i int) {
-			defer consumerWG.Done()
-			for {
-				item, quit := q.Get()
-				if item == "added after shutdown!" {
-					t.Errorf("Got an item added after shutdown.")
-				}
-				if quit {
-					return
-				}
-				t.Logf("Worker %v: begin processing %v", i, item)
-				time.Sleep(3 * time.Millisecond)
-				t.Logf("Worker %v: done processing %v", i, item)
-				q.Done(item)
-			}
-		}(i)
-	}
-
-	producerWG.Wait()
-	q.ShutDown()
-	q.Add("added after shutdown!")
-	consumerWG.Wait()
-}
-
-func TestAddWhileProcessing(t *testing.T) {
-	q := workqueue.New()
-
-	// Start producers
-	const producers = 50
-	producerWG := sync.WaitGroup{}
-	producerWG.Add(producers)
-	for i := 0; i < producers; i++ {
-		go func(i int) {
-			defer producerWG.Done()
-			q.Add(i)
-		}(i)
-	}
-
-	// Start consumers
-	const consumers = 10
-	consumerWG := sync.WaitGroup{}
-	consumerWG.Add(consumers)
-	for i := 0; i < consumers; i++ {
-		go func(i int) {
-			defer consumerWG.Done()
-			// Every worker will re-add every item up to two times.
-			// This tests the dirty-while-processing case.
-			counters := map[interface{}]int{}
-			for {
-				item, quit := q.Get()
-				if quit {
-					return
-				}
-				counters[item]++
-				if counters[item] < 2 {
-					q.Add(item)
-				}
-				q.Done(item)
-			}
-		}(i)
-	}
-
-	producerWG.Wait()
-	q.ShutDown()
-	consumerWG.Wait()
-}
-
-func TestLen(t *testing.T) {
-	q := workqueue.New()
-	q.Add("foo")
-	if e, a := 1, q.Len(); e != a {
-		t.Errorf("Expected %v, got %v", e, a)
-	}
-	q.Add("bar")
-	if e, a := 2, q.Len(); e != a {
-		t.Errorf("Expected %v, got %v", e, a)
-	}
-	q.Add("foo") // should not increase the queue length.
-	if e, a := 2, q.Len(); e != a {
-		t.Errorf("Expected %v, got %v", e, a)
-	}
-}
-
-func TestReinsert(t *testing.T) {
-	q := workqueue.New()
-	q.Add("foo")
-
-	// Start processing
-	i, _ := q.Get()
-	if i != "foo" {
-		t.Errorf("Expected %v, got %v", "foo", i)
-	}
-
-	// Add it back while processing
-	q.Add(i)
-
-	// Finish it up
-	q.Done(i)
-
-	// It should be back on the queue
-	i, _ = q.Get()
-	if i != "foo" {
-		t.Errorf("Expected %v, got %v", "foo", i)
-	}
-
-	// Finish that one up
-	q.Done(i)
-
-	if a := q.Len(); a != 0 {
-		t.Errorf("Expected queue to be empty. Has %v items", a)
-	}
-}

vendor/k8s.io/client-go/util/workqueue/rate_limitting_queue_test.go

@@ -1,75 +0,0 @@
-/*
-Copyright 2016 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 workqueue
-
-import (
-	"testing"
-	"time"
-
-	"k8s.io/apimachinery/pkg/util/clock"
-)
-
-func TestRateLimitingQueue(t *testing.T) {
-	limiter := NewItemExponentialFailureRateLimiter(1*time.Millisecond, 1*time.Second)
-	queue := NewRateLimitingQueue(limiter).(*rateLimitingType)
-	fakeClock := clock.NewFakeClock(time.Now())
-	delayingQueue := &delayingType{
-		Interface:       New(),
-		clock:           fakeClock,
-		heartbeat:       fakeClock.Tick(maxWait),
-		stopCh:          make(chan struct{}),
-		waitingForAddCh: make(chan *waitFor, 1000),
-		metrics:         newRetryMetrics(""),
-	}
-	queue.DelayingInterface = delayingQueue
-
-	queue.AddRateLimited("one")
-	waitEntry := <-delayingQueue.waitingForAddCh
-	if e, a := 1*time.Millisecond, waitEntry.readyAt.Sub(fakeClock.Now()); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	queue.AddRateLimited("one")
-	waitEntry = <-delayingQueue.waitingForAddCh
-	if e, a := 2*time.Millisecond, waitEntry.readyAt.Sub(fakeClock.Now()); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	if e, a := 2, queue.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	queue.AddRateLimited("two")
-	waitEntry = <-delayingQueue.waitingForAddCh
-	if e, a := 1*time.Millisecond, waitEntry.readyAt.Sub(fakeClock.Now()); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	queue.AddRateLimited("two")
-	waitEntry = <-delayingQueue.waitingForAddCh
-	if e, a := 2*time.Millisecond, waitEntry.readyAt.Sub(fakeClock.Now()); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-	queue.Forget("one")
-	if e, a := 0, queue.NumRequeues("one"); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-	queue.AddRateLimited("one")
-	waitEntry = <-delayingQueue.waitingForAddCh
-	if e, a := 1*time.Millisecond, waitEntry.readyAt.Sub(fakeClock.Now()); e != a {
-		t.Errorf("expected %v, got %v", e, a)
-	}
-
-}