Fix unit tests

main/agent.go

@@ -31,7 +31,6 @@ func runAgent(opts boshapp.Options, logger logger.Logger) chan error {
 		}
 
 		app := boshapp.New(logger, fs)
-
 		err := app.Setup(opts)
 		if err != nil {
 			logger.Error(mainLogTag, "App setup %s", err.Error())

platform/dummy_platform_test.go

@@ -73,7 +73,7 @@ var _ = Describe("DummyPlatform", func() {
 			err := fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`)
 			Expect(err).NotTo(HaveOccurred())
 
-			network, err := platform.GetDefaultNetwork()
+			network, err := platform.GetDefaultNetwork(false)
 			Expect(err).NotTo(HaveOccurred())
 
 			Expect(network.IP).To(Equal("1.2.3.4"))

platform/linux_platform_test.go

@@ -4136,15 +4136,17 @@ unit: sectors
 	})
 
 	Describe("GetDefaultNetwork", func() {
-		It("delegates to the defaultNetworkResolver", func() {
-			defaultNetwork := boshsettings.Network{IP: "1.2.3.4"}
-			fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork
-
-			network, err := platform.GetDefaultNetwork()
-			Expect(err).ToNot(HaveOccurred())
-
-			Expect(network).To(Equal(defaultNetwork))
-		})
+		for _, value := range []bool{true, false} {
+			title := fmt.Sprintf("delegates to the defaultNetworkResolver with input param %t", value)
+			It(title, func() {
+				defaultNetwork := boshsettings.Network{}
+				fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork
+				network, err := platform.GetDefaultNetwork(value)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(network).To(Equal(defaultNetwork))
+				Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalledWith).To(Equal(value))
+			})
+		}
 	})
 
 	Describe("GetHostPublicKey", func() {

platform/net/arp/arping_test.go

@@ -19,7 +19,7 @@ type failingInterfaceAddress struct{}
 
 func (ia failingInterfaceAddress) GetInterfaceName() string { return "eth0" }
 
-func (ia failingInterfaceAddress) GetIP() (string, error) {
+func (ia failingInterfaceAddress) GetIP(IsVersion6 bool) (string, error) {
 	return "", errors.New("fake-get-ip-err")
 }
 

platform/net/default_network_resolver.go

@@ -38,15 +38,14 @@ func (r defaultNetworkResolver) GetDefaultNetwork(is_ipv6 bool) (boshsettings.Ne
 	}
 
 	for _, route := range routes {
-		if !route.IsDefault() {
+		if !route.IsDefault(is_ipv6) {
 			continue
 		}
 
 		ip, err := r.ipResolver.GetPrimaryIP(route.InterfaceName, is_ipv6)
 
 		if err != nil {
 			ipVersion := 4
-
 			if is_ipv6 {
 				ipVersion = 6
 			}

platform/net/default_network_resolver_test.go

@@ -45,14 +45,14 @@ var _ = Describe("defaultNetworkResolver", func() {
 
 			Context("when primary IPv4 exists for the found route", func() {
 				BeforeEach(func() {
-					ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{
+					ipResolver.GetPrimaryIPNet = &gonet.IPNet{
 						IP:   gonet.ParseIP("127.0.0.1"),
 						Mask: gonet.CIDRMask(16, 32),
 					}
 				})
 
 				It("returns network with primary IPv4 address from associated interface", func() {
-					network, err := resolver.GetDefaultNetwork()
+					network, err := resolver.GetDefaultNetwork(false)
 					Expect(err).ToNot(HaveOccurred())
 					Expect(network).To(Equal(boshsettings.Network{
 						IP:      "127.0.0.1",
@@ -64,11 +64,11 @@ var _ = Describe("defaultNetworkResolver", func() {
 
 			Context("when primary IPv4 does not exist for the found route", func() {
 				BeforeEach(func() {
-					ipResolver.GetPrimaryIPv4Err = errors.New("fake-get-primary-ipv4-err")
+					ipResolver.GetPrimaryIPErr = errors.New("fake-get-primary-ipv4-err")
 				})
 
 				It("returns error", func() {
-					network, err := resolver.GetDefaultNetwork()
+					network, err := resolver.GetDefaultNetwork(false)
 					Expect(err).To(HaveOccurred())
 					Expect(err.Error()).To(ContainSubstring("fake-get-primary-ipv4-err"))
 					Expect(network).To(Equal(boshsettings.Network{}))
@@ -86,7 +86,7 @@ var _ = Describe("defaultNetworkResolver", func() {
 			})
 
 			It("returns error", func() {
-				network, err := resolver.GetDefaultNetwork()
+				network, err := resolver.GetDefaultNetwork(false)
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("Failed to find default route"))
 				Expect(network).To(Equal(boshsettings.Network{}))
@@ -99,7 +99,7 @@ var _ = Describe("defaultNetworkResolver", func() {
 			})
 
 			It("returns error if there are no routes", func() {
-				network, err := resolver.GetDefaultNetwork()
+				network, err := resolver.GetDefaultNetwork(false)
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("No routes"))
 				Expect(network).To(Equal(boshsettings.Network{}))
@@ -112,7 +112,7 @@ var _ = Describe("defaultNetworkResolver", func() {
 			})
 
 			It("returns error if searching routes fails", func() {
-				network, err := resolver.GetDefaultNetwork()
+				network, err := resolver.GetDefaultNetwork(false)
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("fake-search-routes-err"))
 				Expect(network).To(Equal(boshsettings.Network{}))

platform/net/fakes/fake_default_network_resolver.go

@@ -5,12 +5,14 @@ import (
 )
 
 type FakeDefaultNetworkResolver struct {
-	GetDefaultNetworkNetwork boshsettings.Network
-	GetDefaultNetworkErr     error
-	GetDefaultNetworkCalled  bool
+	GetDefaultNetworkNetwork    boshsettings.Network
+	GetDefaultNetworkErr        error
+	GetDefaultNetworkCalled     bool
+	GetDefaultNetworkCalledWith bool
 }
 
-func (r *FakeDefaultNetworkResolver) GetDefaultNetwork() (boshsettings.Network, error) {
+func (r *FakeDefaultNetworkResolver) GetDefaultNetwork(isIpv6 bool) (boshsettings.Network, error) {
 	r.GetDefaultNetworkCalled = true
+	r.GetDefaultNetworkCalledWith = isIpv6
 	return r.GetDefaultNetworkNetwork, r.GetDefaultNetworkErr
 }

platform/net/ip/fakes/fake_ip_resolver.go

@@ -1,16 +1,20 @@
 package fakes
 
 import (
+	"fmt"
 	gonet "net"
 )
 
 type FakeResolver struct {
 	GetPrimaryIPInterfaceName string
-	GetPrimaryIPIPNet         *gonet.IPNet
+	GetPrimaryIPNet           *gonet.IPNet
 	GetPrimaryIPErr           error
+	GetPrimaryIPCalledWith    []string
 }
 
 func (r *FakeResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) {
 	r.GetPrimaryIPInterfaceName = interfaceName
-	return r.GetPrimaryIPIPNet, r.GetPrimaryIPErr
+	r.GetPrimaryIPCalledWith = append(r.GetPrimaryIPCalledWith, interfaceName)
+	r.GetPrimaryIPCalledWith = append(r.GetPrimaryIPCalledWith, fmt.Sprintf("%t", is_ipv6))
+	return r.GetPrimaryIPNet, r.GetPrimaryIPErr
 }

platform/net/ip/interface_address_test.go

@@ -2,6 +2,7 @@ package ip_test
 
 import (
 	"errors"
+	"fmt"
 	gonet "net"
 
 	. "github.com/onsi/ginkgo/v2"
@@ -14,23 +15,23 @@ import (
 var _ = Describe("simpleInterfaceAddress", func() {
 	Describe("GetIP", func() {
 		It("returns fully formatted IPv4", func() {
-			ipStr, err := NewSimpleInterfaceAddress("iface", "127.0.0.1").GetIP()
+			ipStr, err := NewSimpleInterfaceAddress("iface", "127.0.0.1").GetIP(false)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(ipStr).To(Equal("127.0.0.1"))
 		})
 
 		It("returns fully formatted IPv6", func() {
-			ipStr, err := NewSimpleInterfaceAddress("iface", "ff00:f8::").GetIP()
+			ipStr, err := NewSimpleInterfaceAddress("iface", "ff00:f8::").GetIP(true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(ipStr).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000"))
 
-			ipStr, err = NewSimpleInterfaceAddress("iface", "1101:2202:3303:4404:5505:6606:7707:8808").GetIP()
+			ipStr, err = NewSimpleInterfaceAddress("iface", "1101:2202:3303:4404:5505:6606:7707:8808").GetIP(true)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(ipStr).To(Equal("1101:2202:3303:4404:5505:6606:7707:8808"))
 		})
 
 		It("returns error if IP cannot be parsed", func() {
-			_, err := NewSimpleInterfaceAddress("iface", "").GetIP()
+			_, err := NewSimpleInterfaceAddress("iface", "").GetIP(false)
 			Expect(err).To(HaveOccurred())
 			Expect(err.Error()).To(Equal("Cannot parse IP ''"))
 		})
@@ -51,37 +52,37 @@ var _ = Describe("resolvingInterfaceAddress", func() {
 	Describe("GetIP", func() {
 		Context("when IP was not yet resolved", func() {
 			BeforeEach(func() {
-				ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{
+				ipResolver.GetPrimaryIPNet = &gonet.IPNet{
 					IP:   gonet.ParseIP("127.0.0.1"),
 					Mask: gonet.CIDRMask(16, 32),
 				}
 			})
 
 			It("resolves the IP and returns fully formatted IPv4", func() {
-				ip, err := interfaceAddress.GetIP()
+				ip, err := interfaceAddress.GetIP(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(ip).To(Equal("127.0.0.1"))
 
-				Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal("fake-iface-name"))
+				Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("fake-iface-name"))
 			})
 
 			It("resolves the IP and returns fully formatted IPv6", func() {
-				ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{
+				ipResolver.GetPrimaryIPNet = &gonet.IPNet{
 					IP:   gonet.ParseIP("ff00:f8::"),
 					Mask: gonet.CIDRMask(64, 128),
 				}
 
-				ip, err := interfaceAddress.GetIP()
+				ip, err := interfaceAddress.GetIP(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(ip).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000"))
 
-				Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal("fake-iface-name"))
+				Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("fake-iface-name"))
 			})
 
 			It("returns error if resolving IP fails", func() {
-				ipResolver.GetPrimaryIPv4Err = errors.New("fake-get-primary-ipv4-err")
+				ipResolver.GetPrimaryIPErr = errors.New("fake-get-primary-ipv4-err")
 
-				ip, err := interfaceAddress.GetIP()
+				ip, err := interfaceAddress.GetIP(false)
 				Expect(err).To(HaveOccurred())
 				Expect(err.Error()).To(ContainSubstring("fake-get-primary-ipv4-err"))
 				Expect(ip).To(Equal(""))
@@ -90,24 +91,44 @@ var _ = Describe("resolvingInterfaceAddress", func() {
 
 		Context("when IP was already resolved", func() {
 			BeforeEach(func() {
-				ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{
+				ipResolver.GetPrimaryIPNet = &gonet.IPNet{
 					IP:   gonet.ParseIP("127.0.0.1"),
 					Mask: gonet.CIDRMask(16, 32),
 				}
 
-				_, err := interfaceAddress.GetIP()
+				_, err := interfaceAddress.GetIP(false)
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("does not attempt to resolve IP again", func() {
-				ipResolver.GetPrimaryIPv4InterfaceName = ""
+				ipResolver.GetPrimaryIPInterfaceName = ""
 
-				ip, err := interfaceAddress.GetIP()
+				ip, err := interfaceAddress.GetIP(false)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(ip).To(Equal("127.0.0.1"))
 
-				Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal(""))
+				Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal(""))
 			})
 		})
+
+		Context("when GetIP was called with true or false", func() {
+
+			BeforeEach(func() {
+				ipResolver.GetPrimaryIPNet = &gonet.IPNet{
+					IP:   gonet.ParseIP("127.0.0.1"),
+					Mask: gonet.CIDRMask(16, 32),
+				}
+			})
+
+			for _, value := range []bool{true, false} {
+				valueStr := fmt.Sprintf("%t", value)
+				It("it should have been called ipResolver with same value: "+valueStr, func() {
+					_, err := interfaceAddress.GetIP(value)
+					Expect(err).ToNot(HaveOccurred())
+					Expect(ipResolver.GetPrimaryIPCalledWith).To(Equal([]string{"fake-iface-name", valueStr}))
+				})
+			}
+
+		})
 	})
 })

platform/net/ip/interface_addresses_provider_test.go

@@ -22,7 +22,7 @@ var _ = Describe("InterfaceAddressesProvider", func() {
 
 		var loopBackInterface InterfaceAddress
 		for _, iface := range ifaces {
-			ip, err := iface.GetIP()
+			ip, err := iface.GetIP(false)
 			Expect(err).ToNot(HaveOccurred())
 
 			if ip == "127.0.0.1" {

platform/net/ip/ip_resolver.go

@@ -40,26 +40,38 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN
 		return nil, bosherr.Errorf("No addresses found for interface '%s'", interfaceName)
 	}
 
+	var foundNonGlobalUniCast *gonet.IPNet
+
 	for _, addr := range addrs {
 		ip, ok := addr.(*gonet.IPNet)
+
 		if !ok {
 			continue
 		}
 
-		if is_ipv6 {
-			if ip.IP.To16() != nil || ip.IP.IsGlobalUnicast() {
-				return ip, nil
-			}
-		} else {
-			if ip.IP.To4() != nil || ip.IP.IsGlobalUnicast() {
+		if ip.IP.To16() != nil && ip.IP.IsGlobalUnicast() && is_ipv6 {
+			return ip, nil
+		}
+
+		if ip.IP.To4() != nil && !is_ipv6 {
+			if ip.IP.IsGlobalUnicast() {
 				return ip, nil
+			} else {
+				if foundNonGlobalUniCast == nil {
+					foundNonGlobalUniCast = ip
+				}
 			}
 		}
 	}
+
 	ipVersion := 4
 	if is_ipv6 {
 		ipVersion = 6
-	} 
+	}
+
+	if foundNonGlobalUniCast != nil {
+		return foundNonGlobalUniCast, nil
+	}
 
 	return nil, bosherr.Errorf("Failed to find primary address IPv%d for interface '%s'", ipVersion, interfaceName)
 }