Remove caching (the lib code is fast) and add tests

gopsutil/systeminfo.go

@@ -10,8 +10,6 @@ var _ pilosa.SystemInfo = NewSystemInfo()
 
 // SystemInfo is an implementation of pilosa.SystemInfo that uses gopsutil to collect information about the host OS
 type SystemInfo struct {
-	hostInfo  *host.InfoStat
-	memInfo   *mem.VirtualMemoryStat
 	platform  string
 	family    string
 	osVersion string
@@ -19,13 +17,23 @@ type SystemInfo struct {
 
 // Uptime returns the system uptime in seconds
 func (s *SystemInfo) Uptime() (uptime uint64, err error) {
-	if s.hostInfo == nil {
-		s.hostInfo, err = host.Info()
+	hostInfo, err := host.Info()
+	if err != nil {
+		return 0, err
+	}
+	return hostInfo.Uptime, nil
+}
+
+// collectPlatformInfo fetches and caches system platform information
+func (s *SystemInfo) collectPlatformInfo() error {
+	var err error
+	if s.platform == "" {
+		s.platform, s.family, s.osVersion, err = host.PlatformInformation()
 		if err != nil {
-			return 0, err
+			return err
 		}
 	}
-	return s.hostInfo.Uptime, nil
+	return nil
 }
 
 // Uptime returns the system platform
@@ -55,54 +63,31 @@ func (s *SystemInfo) OSVersion() (string, error) {
 	return s.osVersion, err
 }
 
-// collectPlatformInfo fetches and caches system platform information
-func (s *SystemInfo) collectPlatformInfo() error {
-	var err error
-	if s.platform == "" {
-		s.platform, s.family, s.osVersion, err = host.PlatformInformation()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// collectMemoryInfo fetches and caches memory stats
-func (s *SystemInfo) collectMemoryInfo() (err error) {
-	if s.memInfo == nil {
-		s.memInfo, err = mem.VirtualMemory()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // MemFree returns the amount of free memory in bytes
 func (s *SystemInfo) MemFree() (uint64, error) {
-	err := s.collectMemoryInfo()
+	memInfo, err := mem.VirtualMemory()
 	if err != nil {
 		return 0, err
 	}
-	return s.memInfo.Free, err
+	return memInfo.Free, err
 }
 
 // MemFree returns the amount of total memory in bytes
 func (s *SystemInfo) MemTotal() (uint64, error) {
-	err := s.collectMemoryInfo()
+	memInfo, err := mem.VirtualMemory()
 	if err != nil {
 		return 0, err
 	}
-	return s.memInfo.Total, err
+	return memInfo.Total, err
 }
 
 // MemFree returns the amount of used memory in bytes
 func (s *SystemInfo) MemUsed() (uint64, error) {
-	err := s.collectMemoryInfo()
+	memInfo, err := mem.VirtualMemory()
 	if err != nil {
 		return 0, err
 	}
-	return s.memInfo.Used, err
+	return memInfo.Used, err
 }
 
 // KernelVersion returns the kernel version as a string

gopsutil/systeminfo_test.go

@@ -0,0 +1,64 @@
+package gopsutil_test
+
+import (
+	"log"
+	"runtime"
+	"testing"
+
+	"github.com/pilosa/pilosa"
+	"github.com/pilosa/pilosa/gopsutil"
+)
+
+func TestSystemInfo(t *testing.T) {
+	var systemInfo pilosa.SystemInfo = gopsutil.NewSystemInfo()
+
+	//	Uptime()(uint64, error)
+	//	Platform()(string, error)
+	//	Family()(string, error)
+	//	OSVersion()(string, error)
+	//	KernelVersion()(string, error)
+	//	MemFree()(uint64, error)
+	//	MemTotal()(uint64, error)
+	//	MemUsed()(uint64, error)
+	//
+	uptime, err := systemInfo.Uptime()
+	if err != nil || uptime == 0 {
+		t.Fatalf("Error collecting uptime (error: %v)", err)
+	}
+
+	platform, err := systemInfo.Platform()
+	if err != nil || platform != runtime.GOOS {
+		t.Fatalf("Platform must be %s. (error: %v)", runtime.GOOS, err)
+	}
+
+	family, err := systemInfo.Family()
+	if err != nil {
+		t.Fatalf("Error getting OS family. (family: %v, error: %v)", family, err)
+	}
+
+	osversion, err := systemInfo.OSVersion()
+	if err != nil {
+		t.Fatalf("Error getting OS version. (osversion: %v, error: %v)", osversion, err)
+	}
+
+	kernelversion, err := systemInfo.KernelVersion()
+	if err != nil {
+		t.Fatalf("Error getting kernel version. (kernelversion: %v, error: %v)", kernelversion, err)
+	}
+
+	memfree, err := systemInfo.MemFree()
+	if err != nil {
+		t.Fatalf("Error getting memfree. (memfree: %v, error: %v)", memfree, err)
+	}
+
+	memused, err := systemInfo.MemUsed()
+	if err != nil {
+		t.Fatalf("Error getting memused. (memused: %v, error: %v)", memused, err)
+	}
+
+	memtotal, err := systemInfo.MemTotal()
+	log.Println(memtotal)
+	if err != nil {
+		t.Fatalf("Error getting memtotal. (memtotal: %v, error: %v)", memtotal, err)
+	}
+}