add ip type check v4 or v6 for both external and internal interfaces. refactor code. add comments.

Author: iqhater

data/external.go

@@ -10,18 +10,18 @@ import (
 
 // ExternalData struct is a external any api resource where data comes from
 type ExternalData struct {
-	ExtIP       string `json:"ip"`
-	Country     string `json:"country"`
-	CountryCode string `json:"cc"`
-	Region      string `json:"region"`
+	ExtIP         string `json:"ip"`
+	Country       string `json:"country"`
+	CountryCode   string `json:"cc"`
+	Region        string `json:"region"`
+	IPAddressType IPType
 }
 
 // GetExternalIP method get response from url and return new ExternalData struct what is for???
 func (e *ExternalData) GetExternalIP(url string, timeout time.Duration) error {
 
-	t := time.Duration(timeout)
 	client := http.Client{
-		Timeout: t,
+		Timeout: time.Duration(timeout),
 	}
 
 	resp, err := client.Get(url)
@@ -30,7 +30,7 @@ func (e *ExternalData) GetExternalIP(url string, timeout time.Duration) error {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
+	if resp.StatusCode != http.StatusOK {
 		return errors.New("Bad response (not 200 status) from host!")
 	}
 
@@ -44,5 +44,11 @@ func (e *ExternalData) GetExternalIP(url string, timeout time.Duration) error {
 		return err
 	}
 
+	// add ip address type
+	ipType, err := getIPType(e.ExtIP)
+	checkErr(err)
+
+	e.IPAddressType = ipType
+
 	return nil
 }

data/internal.go

@@ -3,13 +3,13 @@ package data
 import (
 	"errors"
 	"net"
-	"strings"
 )
 
 // InternalData struct is a local adapter and local ip data.
 type InternalData struct {
-	AdapterName string
-	IntIP       string
+	AdapterName   string
+	IntIP         string
+	IPAddressType IPType
 }
 
 // GetInternalIP get internal local ip addess.
@@ -31,21 +31,36 @@ func (i *InternalData) GetInternalIP() {
 // GetAdapterName get the current local adapter name.
 func (i *InternalData) GetAdapterName() {
 
-	l, err := net.Interfaces()
+	// get all network interfaces
+	networkInterfaces, err := net.Interfaces()
 	checkErr(err)
 
-	for _, f := range l {
+	// loop through all network interfaces
+	for _, networkInterface := range networkInterfaces {
 
-		byNameInterface, err := net.InterfaceByName(f.Name)
+		// get interface info
+		interfaceInfo, err := net.InterfaceByName(networkInterface.Name)
 		checkErr(err)
 
-		addr, err := byNameInterface.Addrs()
+		addresses, err := interfaceInfo.Addrs()
 		checkErr(err)
 
-		for _, v := range addr {
+		// loop through all addresses of the current interface
+		for _, address := range addresses {
 
-			if v.String()[:strings.Index(v.String(), "/")] == i.IntIP {
-				i.AdapterName = f.Name
+			// parse ip address
+			ipAddr, _, err := net.ParseCIDR(address.String())
+			checkErr(err)
+
+			// get type of ip address (IPv4 or IPv6)
+			ipType, err := getIPType(ipAddr.String())
+			checkErr(err)
+
+			// check if ip address match local ip address
+			if ipAddr.String() == i.IntIP {
+				i.AdapterName = networkInterface.Name
+				i.IPAddressType = ipType
+				return
 			}
 		}
 	}

data/ip_type.go

@@ -0,0 +1,26 @@
+package data
+
+import (
+	"errors"
+	"net"
+)
+
+type IPType string
+
+const (
+	IPv4 IPType = "IPv4"
+	IPv6 IPType = "IPv6"
+)
+
+func getIPType(ipStr string) (IPType, error) {
+
+	ip := net.ParseIP(ipStr)
+	if ip == nil {
+		return "", errors.New("Invalid IP address!")
+	}
+
+	if ip.To4() != nil {
+		return IPv4, nil
+	}
+	return IPv6, nil
+}

data/ip_type_test.go

@@ -0,0 +1,45 @@
+package data
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestGetIPType(t *testing.T) {
+
+	// arrange
+	tests := []struct {
+		name     string
+		ipStr    string
+		expected IPType
+		err      error
+	}{
+		{"Valid IPv4", "192.168.0.1", IPv4, nil},
+		{"Valid IPv6", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", IPv6, nil},
+		{"Invalid IP", "invalid", "", errors.New("Invalid IP address!")},
+	}
+
+	for _, tt := range tests {
+
+		t.Run(tt.name, func(t *testing.T) {
+
+			// act
+			ipType, err := getIPType(tt.ipStr)
+
+			// assert
+			if ipType != tt.expected {
+				t.Errorf("Expected IP type %s, but got %s", tt.expected, ipType)
+			}
+
+			if tt.err != nil {
+				if err == nil || err.Error() != tt.err.Error() {
+					t.Errorf("Expected error %s, but got %s", tt.err, err)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Expected no error, but got %s", err)
+				}
+			}
+		})
+	}
+}

view/ui.go

@@ -15,14 +15,14 @@ var out io.Writer = os.Stdout
 // PrintInternal print all internal ip data
 func PrintInternal(d *data.IPData) {
 	color.New(color.FgMagenta).Fprintln(out, "Local interface name:", d.AdapterName)
-	fmt.Fprintln(out, "	 Internal IP:", d.IntIP)
+	fmt.Fprintf(out, "	 Internal IP (%s): %s \n", d.InternalData.IPAddressType, d.IntIP)
 }
 
 // PrintExternal print all external ip data
 func PrintExternal(d *data.IPData) {
 
 	if d.ExtIP != "" {
-		color.New(color.FgGreen).Fprintln(out, "	 External IP:", d.ExtIP)
+		color.New(color.FgGreen).Fprintf(out, "	 External IP (%s): %s \n", d.ExternalData.IPAddressType, d.ExtIP)
 	}
 
 	if d.Country != "" {