github.com/elastic/gosigar@v0.14.3/sigar_interface_test.go (about)

     1  package gosigar_test
     2  
     3  import (
     4  	"os"
     5  	"os/user"
     6  	"path/filepath"
     7  	"runtime"
     8  	"strings"
     9  	"testing"
    10  	"time"
    11  
    12  	. "github.com/elastic/gosigar"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  const invalidPid = 666666
    17  
    18  func TestCpu(t *testing.T) {
    19  	cpu := Cpu{}
    20  	assert.NoError(t, cpu.Get())
    21  }
    22  
    23  func TestLoadAverage(t *testing.T) {
    24  	avg := LoadAverage{}
    25  	assert.NoError(t, skipNotImplemented(t, avg.Get(), "windows"))
    26  }
    27  
    28  func TestUptime(t *testing.T) {
    29  	uptime := Uptime{}
    30  	if assert.NoError(t, uptime.Get()) {
    31  		assert.True(t, uptime.Length > 0, "Uptime (%f) must be positive", uptime.Length)
    32  	}
    33  }
    34  
    35  func TestMem(t *testing.T) {
    36  	mem := Mem{}
    37  	if assert.NoError(t, mem.Get()) {
    38  		assert.True(t, mem.Total > 0, "mem.Total (%d) must be positive", mem.Total)
    39  		assert.True(t, (mem.Used+mem.Free) <= mem.Total,
    40  			"mem.Used (%d) + mem.Free (%d) must <= mem.Total (%d)",
    41  			mem.Used, mem.Free, mem.Total)
    42  	}
    43  }
    44  
    45  func TestSwap(t *testing.T) {
    46  	swap := Swap{}
    47  	if assert.NoError(t, swap.Get()) {
    48  		assert.True(t, (swap.Used+swap.Free) <= swap.Total,
    49  			"swap.Used (%d) + swap.Free (%d) must <= swap.Total (%d)",
    50  			swap.Used, swap.Free, swap.Total)
    51  	}
    52  }
    53  
    54  func TestCpuList(t *testing.T) {
    55  	cpuList := CpuList{}
    56  	if assert.NoError(t, cpuList.Get()) {
    57  		numCore := len(cpuList.List)
    58  		numCpu := runtime.NumCPU()
    59  		assert.True(t, numCore >= numCpu, "Number of cores (%d) >= number of logical CPUs (%d)",
    60  			numCore, numCpu)
    61  	}
    62  }
    63  
    64  func TestFileSystemList(t *testing.T) {
    65  	fsList := FileSystemList{}
    66  	if assert.NoError(t, fsList.Get()) {
    67  		assert.True(t, len(fsList.List) > 0)
    68  	}
    69  }
    70  
    71  func TestFileSystemUsage(t *testing.T) {
    72  	root := "/"
    73  	if runtime.GOOS == "windows" {
    74  		root = `C:\`
    75  	}
    76  	fsusage := FileSystemUsage{}
    77  	if assert.NoError(t, fsusage.Get(root)) {
    78  		assert.True(t, fsusage.Total > 0)
    79  	}
    80  	assert.Error(t, fsusage.Get("T O T A L L Y B O G U S"))
    81  }
    82  
    83  func TestProcList(t *testing.T) {
    84  	pids := ProcList{}
    85  	if assert.NoError(t, pids.Get()) {
    86  		assert.True(t, len(pids.List) > 2)
    87  	}
    88  }
    89  
    90  func TestProcState(t *testing.T) {
    91  	u, err := user.Current()
    92  	if err != nil {
    93  		t.Fatal(err)
    94  	}
    95  
    96  	state := ProcState{}
    97  	if assert.NoError(t, state.Get(os.Getppid())) {
    98  		assert.Contains(t, []RunState{RunStateRun, RunStateSleep}, state.State)
    99  		assert.Regexp(t, "go(.exe)?", state.Name)
   100  		assert.Equal(t, u.Username, state.Username)
   101  		assert.True(t, state.Ppid > 0, "ppid=%v is non-positive", state.Ppid)
   102  	}
   103  	assert.Error(t, state.Get(invalidPid))
   104  }
   105  
   106  func TestProcMem(t *testing.T) {
   107  	mem := ProcMem{}
   108  	assert.NoError(t, mem.Get(os.Getppid()))
   109  
   110  	assert.Error(t, mem.Get(invalidPid))
   111  }
   112  
   113  func TestProcTime(t *testing.T) {
   114  	procTime := ProcTime{}
   115  	if assert.NoError(t, procTime.Get(os.Getppid())) {
   116  		// Sanity check the start time of the "go test" process.
   117  		delta := time.Now().Sub(time.Unix(0, int64(procTime.StartTime*uint64(time.Millisecond))))
   118  		assert.True(t, delta > 0 && delta < 2*time.Minute, "ProcTime.StartTime differs by %v", delta)
   119  	}
   120  
   121  	assert.Error(t, procTime.Get(invalidPid))
   122  }
   123  
   124  func TestProcArgs(t *testing.T) {
   125  	procArgs := ProcArgs{}
   126  	if assert.NoError(t, procArgs.Get(os.Getppid())) {
   127  		assert.NotEmpty(t, procArgs.List)
   128  	}
   129  	if runtime.GOOS != "darwin" {
   130  		assert.Error(t, procArgs.Get(invalidPid))
   131  	}
   132  }
   133  
   134  func TestProcEnv(t *testing.T) {
   135  	env := &ProcEnv{}
   136  	if assert.NoError(t, skipNotImplemented(t, env.Get(os.Getpid()), "windows", "openbsd")) {
   137  		assert.True(t, len(env.Vars) > 0, "env is empty")
   138  
   139  		for k, v := range env.Vars {
   140  			assert.Equal(t, strings.TrimSpace(os.Getenv(k)), strings.TrimSpace(v))
   141  		}
   142  	}
   143  }
   144  
   145  func TestProcExe(t *testing.T) {
   146  	exe := ProcExe{}
   147  	if assert.NoError(t, skipNotImplemented(t, exe.Get(os.Getppid()), "windows")) {
   148  		assert.Regexp(t, "go(.exe)?", filepath.Base(exe.Name))
   149  	}
   150  }
   151  
   152  func skipNotImplemented(t testing.TB, err error, goos ...string) error {
   153  	for _, os := range goos {
   154  		if runtime.GOOS == os {
   155  			if err == nil {
   156  				t.Fatal("expected ErrNotImplemented")
   157  			} else if IsNotImplemented(err) {
   158  				t.Skipf("Skipping test on %s", runtime.GOOS)
   159  			}
   160  
   161  			break
   162  		}
   163  	}
   164  
   165  	return err
   166  }