Fresh dep ensure

vendor/k8s.io/kubernetes/pkg/util/dbus/dbus_test.go

@@ -209,9 +209,8 @@ func TestFakeDBus(t *testing.T) {
 				checkName := args[0].(string)
 				if checkName != ownedName {
 					return nil, godbus.Error{Name: "org.freedesktop.DBus.Error.NameHasNoOwner", Body: nil}
-				} else {
-					return []interface{}{uniqueName}, nil
 				}
+				return []interface{}{uniqueName}, nil
 			} else if method == "org.freedesktop.DBus.RequestName" {
 				reqName := args[0].(string)
 				_ = args[1].(uint32)

vendor/k8s.io/kubernetes/pkg/util/dbus/fake_dbus.go

@@ -23,25 +23,25 @@ import (
 	godbus "github.com/godbus/dbus"
 )
 
-// DBusFake is a simple fake Interface type.
-type DBusFake struct {
-	systemBus  *DBusFakeConnection
-	sessionBus *DBusFakeConnection
+// Fake is a simple fake Interface type.
+type Fake struct {
+	systemBus  *FakeConnection
+	sessionBus *FakeConnection
 }
 
-// DBusFakeConnection represents a fake D-Bus connection
-type DBusFakeConnection struct {
+// FakeConnection represents a fake D-Bus connection
+type FakeConnection struct {
 	lock           sync.Mutex
 	busObject      *fakeObject
 	objects        map[string]*fakeObject
 	signalHandlers []chan<- *godbus.Signal
 }
 
-// DBusFakeHandler is used to handle fake D-Bus method calls
-type DBusFakeHandler func(method string, args ...interface{}) ([]interface{}, error)
+// FakeHandler is used to handle fake D-Bus method calls
+type FakeHandler func(method string, args ...interface{}) ([]interface{}, error)
 
 type fakeObject struct {
-	handler DBusFakeHandler
+	handler FakeHandler
 }
 
 type fakeCall struct {
@@ -50,46 +50,45 @@ type fakeCall struct {
 }
 
 // NewFake returns a new Interface which will fake talking to D-Bus
-func NewFake(systemBus *DBusFakeConnection, sessionBus *DBusFakeConnection) *DBusFake {
-	return &DBusFake{systemBus, sessionBus}
+func NewFake(systemBus *FakeConnection, sessionBus *FakeConnection) *Fake {
+	return &Fake{systemBus, sessionBus}
 }
 
-func NewFakeConnection() *DBusFakeConnection {
-	return &DBusFakeConnection{
+// NewFakeConnection returns a FakeConnection Interface
+func NewFakeConnection() *FakeConnection {
+	return &FakeConnection{
 		objects: make(map[string]*fakeObject),
 	}
 }
 
 // SystemBus is part of Interface
-func (db *DBusFake) SystemBus() (Connection, error) {
+func (db *Fake) SystemBus() (Connection, error) {
 	if db.systemBus != nil {
 		return db.systemBus, nil
-	} else {
-		return nil, fmt.Errorf("DBus is not running")
 	}
+	return nil, fmt.Errorf("DBus is not running")
 }
 
 // SessionBus is part of Interface
-func (db *DBusFake) SessionBus() (Connection, error) {
+func (db *Fake) SessionBus() (Connection, error) {
 	if db.sessionBus != nil {
 		return db.sessionBus, nil
-	} else {
-		return nil, fmt.Errorf("DBus is not running")
 	}
+	return nil, fmt.Errorf("DBus is not running")
 }
 
 // BusObject is part of the Connection interface
-func (conn *DBusFakeConnection) BusObject() Object {
+func (conn *FakeConnection) BusObject() Object {
 	return conn.busObject
 }
 
 // Object is part of the Connection interface
-func (conn *DBusFakeConnection) Object(name, path string) Object {
+func (conn *FakeConnection) Object(name, path string) Object {
 	return conn.objects[name+path]
 }
 
 // Signal is part of the Connection interface
-func (conn *DBusFakeConnection) Signal(ch chan<- *godbus.Signal) {
+func (conn *FakeConnection) Signal(ch chan<- *godbus.Signal) {
 	conn.lock.Lock()
 	defer conn.lock.Unlock()
 	for i := range conn.signalHandlers {
@@ -102,17 +101,17 @@ func (conn *DBusFakeConnection) Signal(ch chan<- *godbus.Signal) {
 }
 
 // SetBusObject sets the handler for the BusObject of conn
-func (conn *DBusFakeConnection) SetBusObject(handler DBusFakeHandler) {
+func (conn *FakeConnection) SetBusObject(handler FakeHandler) {
 	conn.busObject = &fakeObject{handler}
 }
 
 // AddObject adds a handler for the Object at name and path
-func (conn *DBusFakeConnection) AddObject(name, path string, handler DBusFakeHandler) {
+func (conn *FakeConnection) AddObject(name, path string, handler FakeHandler) {
 	conn.objects[name+path] = &fakeObject{handler}
 }
 
 // EmitSignal emits a signal on conn
-func (conn *DBusFakeConnection) EmitSignal(name, path, iface, signal string, args ...interface{}) {
+func (conn *FakeConnection) EmitSignal(name, path, iface, signal string, args ...interface{}) {
 	conn.lock.Lock()
 	defer conn.lock.Unlock()
 	sig := &godbus.Signal{