Lomanic
/
gopsutil
mirror of https://github.com/shirou/gopsutil
1
0
Fork 0
Code Issues Releases Activity

chore: enable begin rule from thelper

Browse Source 
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
pull/1816/head
Matthieu MOREL 1 week ago
parent 92e037d58c
commit a5e496769c
18 changed files with 123 additions and 168 deletions
Show Stats Download Patch File Download Diff File

17
.golangci.yml
Unescape Escape View File

@ -102,23 +102,6 @@ linters-settings:
disabled: true disabled: true
testifylint: testifylint:
enable-all: true enable-all: true
thelper:
test:
# Check t.Helper() begins helper function.
# Default: true
begin: false
benchmark:
# Check b.Helper() begins helper function.
# Default: true
begin: false
tb:
# Check tb.Helper() begins helper function.
# Default: true
begin: false
fuzz:
# Check f.Helper() begins helper function.
# Default: true
begin: false
usetesting: usetesting:
os-create-temp: false os-create-temp: false
os-mkdir-temp: false os-mkdir-temp: false

6
cpu/cpu_linux_test.go
Unescape Escape View File

@ -10,6 +10,8 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/shirou/gopsutil/v4/internal/common"
) )
func TestTimesEmpty(t *testing.T) { func TestTimesEmpty(t *testing.T) {
@ -76,10 +78,10 @@ func TestCountsAgainstLscpu(t *testing.T) {
expectedPhysical := coresPerSocket * sockets * books * drawers expectedPhysical := coresPerSocket * sockets * books * drawers
expectedLogical := expectedPhysical * threadsPerCore expectedLogical := expectedPhysical * threadsPerCore
physical, err := Counts(false) physical, err := Counts(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
logical, err := Counts(true) logical, err := Counts(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Equalf(t, expectedPhysical, physical, "expected %v, got %v", expectedPhysical, physical) assert.Equalf(t, expectedPhysical, physical, "expected %v, got %v", expectedPhysical, physical)
assert.Equalf(t, expectedLogical, logical, "expected %v, got %v", expectedLogical, logical) assert.Equalf(t, expectedLogical, logical, "expected %v, got %v", expectedLogical, logical)

4
cpu/cpu_plan9_test.go
Unescape Escape View File

@ -11,6 +11,8 @@ import (
"github.com/google/go-cmp/cmp/cmpopts" "github.com/google/go-cmp/cmp/cmpopts"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/shirou/gopsutil/v4/internal/common"
) )
var timesTests = []struct { var timesTests = []struct {
@ -35,7 +37,7 @@ func TestTimesPlan9(t *testing.T) {
t.Run(tt.mockedRootFS, func(t *testing.T) { t.Run(tt.mockedRootFS, func(t *testing.T) {
t.Setenv("HOST_ROOT", filepath.Join("testdata/plan9", tt.mockedRootFS)) t.Setenv("HOST_ROOT", filepath.Join("testdata/plan9", tt.mockedRootFS))
stats, err := Times(false) stats, err := Times(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
eps := cmpopts.EquateApprox(0, 0.00000001) eps := cmpopts.EquateApprox(0, 0.00000001)
assert.Truef(t, cmp.Equal(stats, tt.stats, eps), "got: %+v\nwant: %+v", stats, tt.stats) assert.Truef(t, cmp.Equal(stats, tt.stats, eps), "got: %+v\nwant: %+v", stats, tt.stats)

29
cpu/cpu_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package cpu package cpu
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"runtime" "runtime"
@ -15,15 +14,9 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestTimes(t *testing.T) { func TestTimes(t *testing.T) {
v, err := Times(false) v, err := Times(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, v, "could not get CPUs: %s", err) assert.NotEmptyf(t, v, "could not get CPUs: %s", err)
empty := TimesStat{} empty := TimesStat{}
@ -33,11 +26,11 @@ func TestTimes(t *testing.T) {
// test sum of per cpu stats is within margin of error for cpu total stats // test sum of per cpu stats is within margin of error for cpu total stats
cpuTotal, err := Times(false) cpuTotal, err := Times(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, cpuTotal, "could not get CPUs: %s", err) assert.NotEmptyf(t, cpuTotal, "could not get CPUs: %s", err)
perCPU, err := Times(true) perCPU, err := Times(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, perCPU, "could not get CPUs: %s", err) assert.NotEmptyf(t, perCPU, "could not get CPUs: %s", err)
var perCPUUserTimeSum float64 var perCPUUserTimeSum float64
@ -67,12 +60,12 @@ func TestTimes(t *testing.T) {
func TestCounts(t *testing.T) { func TestCounts(t *testing.T) {
v, err := Counts(true) v, err := Counts(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotZerof(t, v, "could not get logical CPU counts: %v", v) assert.NotZerof(t, v, "could not get logical CPU counts: %v", v)
t.Logf("logical cores: %d", v) t.Logf("logical cores: %d", v)
v, err = Counts(false) v, err = Counts(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotZerof(t, v, "could not get physical CPU counts: %v", v) assert.NotZerof(t, v, "could not get physical CPU counts: %v", v)
t.Logf("physical cores: %d", v) t.Logf("physical cores: %d", v)
@ -91,7 +84,7 @@ func TestTimeStat_String(t *testing.T) {
func TestInfo(t *testing.T) { func TestInfo(t *testing.T) {
v, err := Info() v, err := Info()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, v, "could not get CPU Info") assert.NotEmptyf(t, v, "could not get CPU Info")
for _, vv := range v { for _, vv := range v {
@ -100,13 +93,14 @@ func TestInfo(t *testing.T) {
} }
func testPercent(t *testing.T, percpu bool) { func testPercent(t *testing.T, percpu bool) {
t.Helper()
numcpu := runtime.NumCPU() numcpu := runtime.NumCPU()
testCount := 3 testCount := 3
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
testCount = 100 testCount = 100
v, err := Percent(time.Millisecond, percpu) v, err := Percent(time.Millisecond, percpu)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
// Skip CI which CPU num is different // Skip CI which CPU num is different
if os.Getenv("CI") != "true" { if os.Getenv("CI") != "true" {
@ -118,7 +112,7 @@ func testPercent(t *testing.T, percpu bool) {
for i := 0; i < testCount; i++ { for i := 0; i < testCount; i++ {
duration := time.Duration(10) * time.Microsecond duration := time.Duration(10) * time.Microsecond
v, err := Percent(duration, percpu) v, err := Percent(duration, percpu)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
for _, percent := range v { for _, percent := range v {
// Check for slightly greater then 100% to account for any rounding issues. // Check for slightly greater then 100% to account for any rounding issues.
@ -130,13 +124,14 @@ func testPercent(t *testing.T, percpu bool) {
} }
func testPercentLastUsed(t *testing.T, percpu bool) { func testPercentLastUsed(t *testing.T, percpu bool) {
t.Helper()
numcpu := runtime.NumCPU() numcpu := runtime.NumCPU()
testCount := 10 testCount := 10
if runtime.GOOS != "windows" { if runtime.GOOS != "windows" {
testCount = 2 testCount = 2
v, err := Percent(time.Millisecond, percpu) v, err := Percent(time.Millisecond, percpu)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
// Skip CI which CPU num is different // Skip CI which CPU num is different
if os.Getenv("CI") != "true" { if os.Getenv("CI") != "true" {
@ -147,7 +142,7 @@ func testPercentLastUsed(t *testing.T, percpu bool) {
} }
for i := 0; i < testCount; i++ { for i := 0; i < testCount; i++ {
v, err := Percent(0, percpu) v, err := Percent(0, percpu)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
time.Sleep(1 * time.Millisecond) time.Sleep(1 * time.Millisecond)
for _, percent := range v { for _, percent := range v {

13
disk/disk_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package disk package disk
import ( import (
"errors"
"fmt" "fmt"
"runtime" "runtime"
"sync" "sync"
@ -14,26 +13,20 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestUsage(t *testing.T) { func TestUsage(t *testing.T) {
path := "/" path := "/"
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
path = "C:" path = "C:"
} }
v, err := Usage(path) v, err := Usage(path)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Equalf(t, v.Path, path, "error %v", err) assert.Equalf(t, v.Path, path, "error %v", err)
} }
func TestPartitions(t *testing.T) { func TestPartitions(t *testing.T) {
ret, err := Partitions(false) ret, err := Partitions(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
if err != nil || len(ret) == 0 { if err != nil || len(ret) == 0 {
t.Errorf("error %v", err) t.Errorf("error %v", err)
} }
@ -47,7 +40,7 @@ func TestPartitions(t *testing.T) {
func TestIOCounters(t *testing.T) { func TestIOCounters(t *testing.T) {
ret, err := IOCounters() ret, err := IOCounters()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, ret, "ret is empty") assert.NotEmptyf(t, ret, "ret is empty")
empty := IOCountersStat{} empty := IOCountersStat{}

27
host/host_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package host package host
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"sync" "sync"
@ -14,15 +13,9 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestHostID(t *testing.T) { func TestHostID(t *testing.T) {
v, err := HostID() v, err := HostID()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, v, "Could not get host id %v", v) assert.NotEmptyf(t, v, "Could not get host id %v", v)
t.Log(v) t.Log(v)
@ -30,7 +23,7 @@ func TestHostID(t *testing.T) {
func TestInfo(t *testing.T) { func TestInfo(t *testing.T) {
v, err := Info() v, err := Info()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &InfoStat{} empty := &InfoStat{}
assert.NotSamef(t, v, empty, "Could not get hostinfo %v", v) assert.NotSamef(t, v, empty, "Could not get hostinfo %v", v)
@ -44,7 +37,7 @@ func TestUptime(t *testing.T) {
} }
v, err := Uptime() v, err := Uptime()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotZerof(t, v, "Could not get up time %v", v) assert.NotZerof(t, v, "Could not get up time %v", v)
} }
@ -54,14 +47,14 @@ func TestBootTime(t *testing.T) {
t.Skip("Skip CI") t.Skip("Skip CI")
} }
v, err := BootTime() v, err := BootTime()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotZerof(t, v, "Could not get boot time %v", v) assert.NotZerof(t, v, "Could not get boot time %v", v)
assert.GreaterOrEqualf(t, v, 946652400, "Invalid Boottime, older than 2000-01-01") assert.GreaterOrEqualf(t, v, 946652400, "Invalid Boottime, older than 2000-01-01")
t.Logf("first boot time: %d", v) t.Logf("first boot time: %d", v)
v2, err := BootTime() v2, err := BootTime()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Equalf(t, v, v2, "cached boot time is different") assert.Equalf(t, v, v2, "cached boot time is different")
t.Logf("second boot time: %d", v2) t.Logf("second boot time: %d", v2)
@ -69,7 +62,7 @@ func TestBootTime(t *testing.T) {
func TestUsers(t *testing.T) { func TestUsers(t *testing.T) {
v, err := Users() v, err := Users()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := UserStat{} empty := UserStat{}
if len(v) == 0 { if len(v) == 0 {
@ -109,7 +102,7 @@ func TestUserStat_String(t *testing.T) {
func TestGuid(t *testing.T) { func TestGuid(t *testing.T) {
id, err := HostID() id, err := HostID()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, id, "Host id is empty") assert.NotEmptyf(t, id, "Host id is empty")
t.Logf("Host id value: %v", id) t.Logf("Host id value: %v", id)
@ -123,7 +116,7 @@ func TestVirtualization(t *testing.T) {
go func(j int) { go func(j int) {
system, role, err := Virtualization() system, role, err := Virtualization()
wg.Done() wg.Done()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
assert.NoErrorf(t, err, "Virtualization() failed, %v", err) assert.NoErrorf(t, err, "Virtualization() failed, %v", err)
if j == 9 { if j == 9 {
@ -136,7 +129,7 @@ func TestVirtualization(t *testing.T) {
func TestKernelVersion(t *testing.T) { func TestKernelVersion(t *testing.T) {
version, err := KernelVersion() version, err := KernelVersion()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "KernelVersion() failed, %v", err) require.NoErrorf(t, err, "KernelVersion() failed, %v", err)
assert.NotEmptyf(t, version, "KernelVersion() returns empty: %s", version) assert.NotEmptyf(t, version, "KernelVersion() returns empty: %s", version)
@ -145,7 +138,7 @@ func TestKernelVersion(t *testing.T) {
func TestPlatformInformation(t *testing.T) { func TestPlatformInformation(t *testing.T) {
platform, family, version, err := PlatformInformation() platform, family, version, err := PlatformInformation()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "PlatformInformation() failed, %v", err) require.NoErrorf(t, err, "PlatformInformation() failed, %v", err)
assert.NotEmptyf(t, platform, "PlatformInformation() returns empty: %v", platform) assert.NotEmptyf(t, platform, "PlatformInformation() returns empty: %v", platform)

3
internal/common/common.go
Unescape Escape View File

@ -32,6 +32,7 @@ import (
var ( var (
Timeout = 3 * time.Second Timeout = 3 * time.Second
ErrNotImplementedError = errors.New("not implemented yet")
ErrTimeout = errors.New("command timed out") ErrTimeout = errors.New("command timed out")
) )
@ -97,8 +98,6 @@ func (i FakeInvoke) CommandWithContext(ctx context.Context, name string, arg ...
return i.Command(name, arg...) return i.Command(name, arg...)
} }
var ErrNotImplementedError = errors.New("not implemented yet")
// ReadFile reads contents from a file // ReadFile reads contents from a file
func ReadFile(filename string) (string, error) { func ReadFile(filename string) (string, error) {
content, err := os.ReadFile(filename) content, err := os.ReadFile(filename)

14
internal/common/common_testing.go
Unescape Escape View File

@ -0,0 +1,14 @@
// SPDX-License-Identifier: BSD-3-Clause
package common
import (
"errors"
"testing"
)
func SkipIfNotImplementedErr(tb testing.TB, err error) {
tb.Helper()
if errors.Is(err, ErrNotImplementedError) {
tb.Skip("not implemented")
}
}

14
load/load_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package load package load
import ( import (
"errors"
"fmt" "fmt"
"testing" "testing"
@ -12,15 +11,9 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(tb testing.TB, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
tb.Skip("not implemented")
}
}
func TestAvg(t *testing.T) { func TestAvg(t *testing.T) {
v, err := Avg() v, err := Avg()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &AvgStat{} empty := &AvgStat{}
@ -41,7 +34,7 @@ func TestAvgStat_String(t *testing.T) {
func TestMisc(t *testing.T) { func TestMisc(t *testing.T) {
v, err := Misc() v, err := Misc()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &MiscStat{} empty := &MiscStat{}
@ -64,8 +57,9 @@ func TestMiscStatString(t *testing.T) {
func BenchmarkLoad(b *testing.B) { func BenchmarkLoad(b *testing.B) {
loadAvg := func(tb testing.TB) { loadAvg := func(tb testing.TB) {
tb.Helper()
v, err := Avg() v, err := Avg()
skipIfNotImplementedErr(tb, err) common.SkipIfNotImplementedErr(tb, err)
require.NoErrorf(tb, err, "error %v", err) require.NoErrorf(tb, err, "error %v", err)
empty := &AvgStat{} empty := &AvgStat{}
assert.NotSamef(tb, v, empty, "error load: %v", v) assert.NotSamef(tb, v, empty, "error load: %v", v)

4
mem/mem_linux_test.go
Unescape Escape View File

@ -12,6 +12,8 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/shirou/gopsutil/v4/internal/common"
) )
func TestExVirtualMemory(t *testing.T) { func TestExVirtualMemory(t *testing.T) {
@ -127,7 +129,7 @@ func TestVirtualMemoryLinux(t *testing.T) {
t.Setenv("HOST_PROC", filepath.Join("testdata/linux/virtualmemory/", tt.mockedRootFS, "proc")) t.Setenv("HOST_PROC", filepath.Join("testdata/linux/virtualmemory/", tt.mockedRootFS, "proc"))
stat, err := VirtualMemory() stat, err := VirtualMemory()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(stat, tt.stat), "got: %+v\nwant: %+v", stat, tt.stat) assert.Truef(t, reflect.DeepEqual(stat, tt.stat), "got: %+v\nwant: %+v", stat, tt.stat)
}) })

6
mem/mem_plan9_test.go
Unescape Escape View File

@ -9,6 +9,8 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/shirou/gopsutil/v4/internal/common"
) )
var virtualMemoryTests = []struct { var virtualMemoryTests = []struct {
@ -34,7 +36,7 @@ func TestVirtualMemoryPlan9(t *testing.T) {
t.Setenv("HOST_ROOT", "testdata/plan9/virtualmemory/") t.Setenv("HOST_ROOT", "testdata/plan9/virtualmemory/")
stat, err := VirtualMemory() stat, err := VirtualMemory()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(stat, tt.stat), "got: %+v\nwant: %+v", stat, tt.stat) assert.Truef(t, reflect.DeepEqual(stat, tt.stat), "got: %+v\nwant: %+v", stat, tt.stat)
}) })
@ -60,7 +62,7 @@ func TestSwapMemoryPlan9(t *testing.T) {
t.Setenv("HOST_ROOT", "testdata/plan9/virtualmemory/") t.Setenv("HOST_ROOT", "testdata/plan9/virtualmemory/")
swap, err := SwapMemory() swap, err := SwapMemory()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Truef(t, reflect.DeepEqual(swap, tt.swap), "got: %+v\nwant: %+v", swap, tt.swap) assert.Truef(t, reflect.DeepEqual(swap, tt.swap), "got: %+v\nwant: %+v", swap, tt.swap)
}) })

13
mem/mem_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package mem package mem
import ( import (
"errors"
"fmt" "fmt"
"runtime" "runtime"
"testing" "testing"
@ -13,19 +12,13 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestVirtualMemory(t *testing.T) { func TestVirtualMemory(t *testing.T) {
if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" { if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
t.Skip("Only .Total .Available are supported on Solaris/illumos") t.Skip("Only .Total .Available are supported on Solaris/illumos")
} }
v, err := VirtualMemory() v, err := VirtualMemory()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &VirtualMemoryStat{} empty := &VirtualMemoryStat{}
assert.NotSamef(t, v, empty, "error %v", v) assert.NotSamef(t, v, empty, "error %v", v)
@ -66,7 +59,7 @@ func TestVirtualMemory(t *testing.T) {
func TestSwapMemory(t *testing.T) { func TestSwapMemory(t *testing.T) {
v, err := SwapMemory() v, err := SwapMemory()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &SwapMemoryStat{} empty := &SwapMemoryStat{}
assert.NotSamef(t, v, empty, "error %v", v) assert.NotSamef(t, v, empty, "error %v", v)
@ -106,7 +99,7 @@ func TestSwapMemoryStat_String(t *testing.T) {
func TestSwapDevices(t *testing.T) { func TestSwapDevices(t *testing.T) {
v, err := SwapDevices() v, err := SwapDevices()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "error calling SwapDevices: %v", err) require.NoErrorf(t, err, "error calling SwapDevices: %v", err)
t.Logf("SwapDevices() -> %+v", v) t.Logf("SwapDevices() -> %+v", v)

1
net/net_darwin_test.go
Unescape Escape View File

@ -40,6 +40,7 @@ func TestParseNetstatLineHeader(t *testing.T) {
} }
func assertLoopbackStat(t *testing.T, err error, stat *IOCountersStat) { func assertLoopbackStat(t *testing.T, err error, stat *IOCountersStat) {
t.Helper()
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, uint64(869107), stat.PacketsRecv) assert.Equal(t, uint64(869107), stat.PacketsRecv)
assert.Equal(t, uint64(0), stat.Errin) assert.Equal(t, uint64(0), stat.Errin)

1
net/net_linux_test.go
Unescape Escape View File

@ -82,6 +82,7 @@ func TestIOCountersByFileParsing(t *testing.T) {
func TestGetProcInodesAll(t *testing.T) { func TestGetProcInodesAll(t *testing.T) {
waitForServer := make(chan bool) waitForServer := make(chan bool)
go func(t *testing.T) { // TCP listening goroutine to have some opened inodes even in CI go func(t *testing.T) { // TCP listening goroutine to have some opened inodes even in CI
t.Helper()
addr, err := net.ResolveTCPAddr("tcp", "localhost:0") // dynamically get a random open port from OS addr, err := net.ResolveTCPAddr("tcp", "localhost:0") // dynamically get a random open port from OS
if err != nil { if err != nil {
t.Skipf("unable to resolve localhost: %v", err) t.Skipf("unable to resolve localhost: %v", err)

23
net/net_test.go
Unescape Escape View File

@ -2,7 +2,6 @@
package net package net
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"runtime" "runtime"
@ -14,12 +13,6 @@ import (
"github.com/shirou/gopsutil/v4/internal/common" "github.com/shirou/gopsutil/v4/internal/common"
) )
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestAddrString(t *testing.T) { func TestAddrString(t *testing.T) {
v := Addr{IP: "192.168.0.1", Port: 8000} v := Addr{IP: "192.168.0.1", Port: 8000}
@ -62,10 +55,10 @@ func TestConnectionStatString(t *testing.T) {
func TestIOCountersAll(t *testing.T) { func TestIOCountersAll(t *testing.T) {
v, err := IOCounters(false) v, err := IOCounters(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err) require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err)
per, err := IOCounters(true) per, err := IOCounters(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err) require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err)
assert.Lenf(t, v, 1, "Could not get NetIOCounters: %v", v) assert.Lenf(t, v, 1, "Could not get NetIOCounters: %v", v)
assert.Equalf(t, "all", v[0].Name, "Invalid NetIOCounters: %v", v) assert.Equalf(t, "all", v[0].Name, "Invalid NetIOCounters: %v", v)
@ -92,7 +85,7 @@ func TestIOCountersAll(t *testing.T) {
func TestIOCountersPerNic(t *testing.T) { func TestIOCountersPerNic(t *testing.T) {
v, err := IOCounters(true) v, err := IOCounters(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err) require.NoErrorf(t, err, "Could not get NetIOCounters: %v", err)
assert.NotEmptyf(t, v, "Could not get NetIOCounters: %v", v) assert.NotEmptyf(t, v, "Could not get NetIOCounters: %v", v)
for _, vv := range v { for _, vv := range v {
@ -123,7 +116,7 @@ func TestGetNetIOCountersAll(t *testing.T) {
func TestInterfaces(t *testing.T) { func TestInterfaces(t *testing.T) {
v, err := Interfaces() v, err := Interfaces()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetInterfaceStat: %v", err) require.NoErrorf(t, err, "Could not get NetInterfaceStat: %v", err)
assert.NotEmptyf(t, v, "Could not get NetInterfaceStat: %v", err) assert.NotEmptyf(t, v, "Could not get NetInterfaceStat: %v", err)
for _, vv := range v { for _, vv := range v {
@ -133,7 +126,7 @@ func TestInterfaces(t *testing.T) {
func TestProtoCountersStatsAll(t *testing.T) { func TestProtoCountersStatsAll(t *testing.T) {
v, err := ProtoCounters(nil) v, err := ProtoCounters(nil)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetProtoCounters: %v", err) require.NoErrorf(t, err, "Could not get NetProtoCounters: %v", err)
require.NotEmptyf(t, v, "Could not get NetProtoCounters: %v", err) require.NotEmptyf(t, v, "Could not get NetProtoCounters: %v", err)
for _, vv := range v { for _, vv := range v {
@ -144,7 +137,7 @@ func TestProtoCountersStatsAll(t *testing.T) {
func TestProtoCountersStats(t *testing.T) { func TestProtoCountersStats(t *testing.T) {
v, err := ProtoCounters([]string{"tcp", "ip"}) v, err := ProtoCounters([]string{"tcp", "ip"})
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "Could not get NetProtoCounters: %v", err) require.NoErrorf(t, err, "Could not get NetProtoCounters: %v", err)
require.NotEmptyf(t, v, "Could not get NetProtoCounters: %v", err) require.NotEmptyf(t, v, "Could not get NetProtoCounters: %v", err)
require.Lenf(t, v, 2, "Go incorrect number of NetProtoCounters: %v", err) require.Lenf(t, v, 2, "Go incorrect number of NetProtoCounters: %v", err)
@ -162,7 +155,7 @@ func TestConnections(t *testing.T) {
} }
v, err := Connections("inet") v, err := Connections("inet")
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "could not get NetConnections: %v", err) require.NoErrorf(t, err, "could not get NetConnections: %v", err)
assert.NotEmptyf(t, v, "could not get NetConnections: %v", v) assert.NotEmptyf(t, v, "could not get NetConnections: %v", v)
for _, vv := range v { for _, vv := range v {
@ -183,7 +176,7 @@ func TestFilterCounters(t *testing.T) {
} }
v, err := FilterCounters() v, err := FilterCounters()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "could not get NetConnections: %v", err) require.NoErrorf(t, err, "could not get NetConnections: %v", err)
assert.NotEmptyf(t, v, "could not get NetConnections: %v", v) assert.NotEmptyf(t, v, "could not get NetConnections: %v", v)
for _, vv := range v { for _, vv := range v {

4
process/process_race_test.go
Unescape Escape View File

@ -8,6 +8,8 @@ import (
"testing" "testing"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/shirou/gopsutil/v4/internal/common"
) )
func TestPpid_Race(t *testing.T) { func TestPpid_Race(t *testing.T) {
@ -19,7 +21,7 @@ func TestPpid_Race(t *testing.T) {
go func(j int) { go func(j int) {
ppid, err := p.Ppid() ppid, err := p.Ppid()
wg.Done() wg.Done()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err, "Ppid() failed, %v", err) require.NoError(t, err, "Ppid() failed, %v", err)
if j == 9 { if j == 9 {

99
process/process_test.go
Unescape Escape View File

@ -3,7 +3,6 @@ package process
import ( import (
"bufio" "bufio"
"errors"
"fmt" "fmt"
"io" "io"
"net" "net"
@ -27,12 +26,6 @@ import (
var mu sync.Mutex var mu sync.Mutex
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func testGetProcess() Process { func testGetProcess() Process {
checkPid := os.Getpid() // process.test checkPid := os.Getpid() // process.test
ret, _ := NewProcess(int32(checkPid)) ret, _ := NewProcess(int32(checkPid))
@ -41,7 +34,7 @@ func testGetProcess() Process {
func TestPids(t *testing.T) { func TestPids(t *testing.T) {
ret, err := Pids() ret, err := Pids()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, ret, "could not get pids %v", ret) assert.NotEmptyf(t, ret, "could not get pids %v", ret)
} }
@ -50,7 +43,7 @@ func TestPid_exists(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := PidExists(int32(checkPid)) ret, err := PidExists(int32(checkPid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.Truef(t, ret, "could not get process exists: %v", ret) assert.Truef(t, ret, "could not get process exists: %v", ret)
@ -60,7 +53,7 @@ func TestNewProcess(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
empty := &Process{} empty := &Process{}
if runtime.GOOS != "windows" { // Windows pid is 0 if runtime.GOOS != "windows" { // Windows pid is 0
@ -72,12 +65,12 @@ func TestMemoryMaps(t *testing.T) {
checkPid := os.Getpid() checkPid := os.Getpid()
ret, err := NewProcess(int32(checkPid)) ret, err := NewProcess(int32(checkPid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
// ungrouped memory maps // ungrouped memory maps
mmaps, err := ret.MemoryMaps(false) mmaps, err := ret.MemoryMaps(false)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "memory map get error %v", err) require.NoErrorf(t, err, "memory map get error %v", err)
empty := MemoryMapsStat{} empty := MemoryMapsStat{}
for _, m := range *mmaps { for _, m := range *mmaps {
@ -86,7 +79,7 @@ func TestMemoryMaps(t *testing.T) {
// grouped memory maps // grouped memory maps
mmaps, err = ret.MemoryMaps(true) mmaps, err = ret.MemoryMaps(true)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "memory map get error %v", err) require.NoErrorf(t, err, "memory map get error %v", err)
assert.Lenf(t, *mmaps, 1, "grouped memory maps length (%v) is not equal to 1", len(*mmaps)) assert.Lenf(t, *mmaps, 1, "grouped memory maps length (%v) is not equal to 1", len(*mmaps))
assert.NotEqualf(t, (*mmaps)[0], empty, "memory map is empty") assert.NotEqualf(t, (*mmaps)[0], empty, "memory map is empty")
@ -96,7 +89,7 @@ func TestMemoryInfo(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.MemoryInfo() v, err := p.MemoryInfo()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting memory info error %v", err) require.NoErrorf(t, err, "getting memory info error %v", err)
empty := MemoryInfoStat{} empty := MemoryInfoStat{}
if v == nil || *v == empty { if v == nil || *v == empty {
@ -108,7 +101,7 @@ func TestCmdLine(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Cmdline() v, err := p.Cmdline()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting cmdline error %v", err) require.NoErrorf(t, err, "getting cmdline error %v", err)
assert.Containsf(t, v, "process.test", "invalid cmd line %v", v) assert.Containsf(t, v, "process.test", "invalid cmd line %v", v)
} }
@ -117,7 +110,7 @@ func TestCmdLineSlice(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.CmdlineSlice() v, err := p.CmdlineSlice()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting cmdline slice error %v", err) require.NoErrorf(t, err, "getting cmdline slice error %v", err)
assert.Truef(t, reflect.DeepEqual(v, os.Args), "returned cmdline slice not as expected:\nexp: %v\ngot: %v", os.Args, v) assert.Truef(t, reflect.DeepEqual(v, os.Args), "returned cmdline slice not as expected:\nexp: %v\ngot: %v", os.Args, v)
} }
@ -126,7 +119,7 @@ func TestPpid(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Ppid() v, err := p.Ppid()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting ppid error %v", err) require.NoErrorf(t, err, "getting ppid error %v", err)
assert.NotZerof(t, v, "return value is 0 %v", v) assert.NotZerof(t, v, "return value is 0 %v", v)
expected := os.Getppid() expected := os.Getppid()
@ -137,7 +130,7 @@ func TestStatus(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Status() v, err := p.Status()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting status error %v", err) require.NoErrorf(t, err, "getting status error %v", err)
assert.NotEmptyf(t, v, "could not get state") assert.NotEmptyf(t, v, "could not get state")
if v[0] != Running && v[0] != Sleep { if v[0] != Running && v[0] != Sleep {
@ -149,7 +142,7 @@ func TestTerminal(t *testing.T) {
p := testGetProcess() p := testGetProcess()
_, err := p.Terminal() _, err := p.Terminal()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
assert.NoErrorf(t, err, "getting terminal error %v", err) assert.NoErrorf(t, err, "getting terminal error %v", err)
} }
@ -157,7 +150,7 @@ func TestIOCounters(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.IOCounters() v, err := p.IOCounters()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting iocounter error %v", err) require.NoErrorf(t, err, "getting iocounter error %v", err)
empty := &IOCountersStat{} empty := &IOCountersStat{}
assert.NotSamef(t, v, empty, "error %v", v) assert.NotSamef(t, v, empty, "error %v", v)
@ -167,7 +160,7 @@ func TestNumCtx(t *testing.T) {
p := testGetProcess() p := testGetProcess()
_, err := p.NumCtxSwitches() _, err := p.NumCtxSwitches()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
assert.NoErrorf(t, err, "getting numctx error %v", err) assert.NoErrorf(t, err, "getting numctx error %v", err)
} }
@ -180,7 +173,7 @@ func TestNice(t *testing.T) {
} }
n, err := p.Nice() n, err := p.Nice()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting nice error %v", err) require.NoErrorf(t, err, "getting nice error %v", err)
if runtime.GOOS != "windows" && n != 0 && n != 20 && n != 8 { if runtime.GOOS != "windows" && n != 0 && n != 20 && n != 8 {
t.Errorf("invalid nice: %d", n) t.Errorf("invalid nice: %d", n)
@ -191,7 +184,7 @@ func TestGroups(t *testing.T) {
p := testGetProcess() p := testGetProcess()
v, err := p.Groups() v, err := p.Groups()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting groups error %v", err) require.NoErrorf(t, err, "getting groups error %v", err)
if len(v) == 0 { if len(v) == 0 {
t.Skip("Groups is empty") t.Skip("Groups is empty")
@ -202,7 +195,7 @@ func TestNumThread(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.NumThreads() n, err := p.NumThreads()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting NumThread error %v", err) require.NoErrorf(t, err, "getting NumThread error %v", err)
assert.GreaterOrEqualf(t, n, int32(0), "invalid NumThread: %d", n) assert.GreaterOrEqualf(t, n, int32(0), "invalid NumThread: %d", n)
} }
@ -211,12 +204,12 @@ func TestThreads(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.NumThreads() n, err := p.NumThreads()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting NumThread error %v", err) require.NoErrorf(t, err, "getting NumThread error %v", err)
assert.GreaterOrEqualf(t, n, int32(0), "invalid NumThread: %d", n) assert.GreaterOrEqualf(t, n, int32(0), "invalid NumThread: %d", n)
ts, err := p.Threads() ts, err := p.Threads()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting Threads error %v", err) require.NoErrorf(t, err, "getting Threads error %v", err)
assert.Equalf(t, len(ts), int(n), "unexpected number of threads: %v vs %v", len(ts), n) assert.Equalf(t, len(ts), int(n), "unexpected number of threads: %v vs %v", len(ts), n)
} }
@ -225,7 +218,7 @@ func TestName(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.Name() n, err := p.Name()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting name error %v", err) require.NoErrorf(t, err, "getting name error %v", err)
assert.Containsf(t, n, "process.test", "invalid Name %s", n) assert.Containsf(t, n, "process.test", "invalid Name %s", n)
} }
@ -254,11 +247,11 @@ func TestLong_Name_With_Spaces(t *testing.T) {
require.NoError(t, cmd.Start()) require.NoError(t, cmd.Start())
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
n, err := p.Name() n, err := p.Name()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting name error %v", err) require.NoErrorf(t, err, "getting name error %v", err)
basename := filepath.Base(tmpfile.Name() + ".exe") basename := filepath.Base(tmpfile.Name() + ".exe")
require.Equalf(t, basename, n, "%s != %s", basename, n) require.Equalf(t, basename, n, "%s != %s", basename, n)
@ -289,11 +282,11 @@ func TestLong_Name(t *testing.T) {
require.NoError(t, cmd.Start()) require.NoError(t, cmd.Start())
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
n, err := p.Name() n, err := p.Name()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting name error %v", err) require.NoErrorf(t, err, "getting name error %v", err)
basename := filepath.Base(tmpfile.Name() + ".exe") basename := filepath.Base(tmpfile.Name() + ".exe")
require.Equalf(t, basename, n, "%s != %s", basename, n) require.Equalf(t, basename, n, "%s != %s", basename, n)
@ -334,10 +327,10 @@ func TestName_Against_Python(t *testing.T) {
pyName := scanner.Text() // first line printed by py3 script, its name pyName := scanner.Text() // first line printed by py3 script, its name
t.Logf("pyName %s", pyName) t.Logf("pyName %s", pyName)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting process error %v", err) require.NoErrorf(t, err, "getting process error %v", err)
name, err := p.Name() name, err := p.Name()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting name error %v", err) require.NoErrorf(t, err, "getting name error %v", err)
require.Equalf(t, pyName, name, "psutil and gopsutil process.Name() results differ: expected %s, got %s", pyName, name) require.Equalf(t, pyName, name, "psutil and gopsutil process.Name() results differ: expected %s, got %s", pyName, name)
} }
@ -346,7 +339,7 @@ func TestExe(t *testing.T) {
p := testGetProcess() p := testGetProcess()
n, err := p.Exe() n, err := p.Exe()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting Exe error %v", err) require.NoErrorf(t, err, "getting Exe error %v", err)
assert.Containsf(t, n, "process.test", "invalid Exe %s", n) assert.Containsf(t, n, "process.test", "invalid Exe %s", n)
} }
@ -354,7 +347,7 @@ func TestExe(t *testing.T) {
func TestCpuPercent(t *testing.T) { func TestCpuPercent(t *testing.T) {
p := testGetProcess() p := testGetProcess()
_, err := p.Percent(0) _, err := p.Percent(0)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
duration := time.Duration(1000) * time.Microsecond duration := time.Duration(1000) * time.Microsecond
time.Sleep(duration) time.Sleep(duration)
@ -373,7 +366,7 @@ func TestCpuPercentLoop(t *testing.T) {
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
duration := time.Duration(100) * time.Microsecond duration := time.Duration(100) * time.Microsecond
percent, err := p.Percent(duration) percent, err := p.Percent(duration)
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
// if percent < 0.0 || percent > 100.0*float64(numcpu) { // TODO // if percent < 0.0 || percent > 100.0*float64(numcpu) { // TODO
require.GreaterOrEqualf(t, percent, 0.0, "CPUPercent value is invalid: %f, %d", percent, numcpu) require.GreaterOrEqualf(t, percent, 0.0, "CPUPercent value is invalid: %f, %d", percent, numcpu)
@ -388,7 +381,7 @@ func TestCreateTime(t *testing.T) {
p := testGetProcess() p := testGetProcess()
c, err := p.CreateTime() c, err := p.CreateTime()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.GreaterOrEqualf(t, c, 1420000000, "process created time is wrong.") assert.GreaterOrEqualf(t, c, 1420000000, "process created time is wrong.")
@ -403,7 +396,7 @@ func TestParent(t *testing.T) {
p := testGetProcess() p := testGetProcess()
c, err := p.Parent() c, err := p.Parent()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
require.NotNilf(t, c, "could not get parent") require.NotNilf(t, c, "could not get parent")
require.NotZerof(t, c.Pid, "wrong parent pid") require.NotZerof(t, c.Pid, "wrong parent pid")
@ -447,7 +440,7 @@ func TestConnections(t *testing.T) {
<-serverEstablished <-serverEstablished
c, err := p.Connections() c, err := p.Connections()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
require.NotEmptyf(t, c, "no connections found") require.NotEmptyf(t, c, "no connections found")
@ -485,7 +478,7 @@ func TestChildren(t *testing.T) {
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
c, err := p.Children() c, err := p.Children()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
require.NotEmptyf(t, c, "children is empty") require.NotEmptyf(t, c, "children is empty")
found := false found := false
@ -505,7 +498,7 @@ func TestUsername(t *testing.T) {
process, _ := NewProcess(int32(myPid)) process, _ := NewProcess(int32(myPid))
pidUsername, err := process.Username() pidUsername, err := process.Username()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
assert.Equal(t, myUsername, pidUsername) assert.Equal(t, myUsername, pidUsername)
t.Log(pidUsername) t.Log(pidUsername)
@ -514,12 +507,12 @@ func TestUsername(t *testing.T) {
func TestCPUTimes(t *testing.T) { func TestCPUTimes(t *testing.T) {
pid := os.Getpid() pid := os.Getpid()
process, err := NewProcess(int32(pid)) process, err := NewProcess(int32(pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
spinSeconds := 0.2 spinSeconds := 0.2
cpuTimes0, err := process.Times() cpuTimes0, err := process.Times()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
// Spin for a duration of spinSeconds // Spin for a duration of spinSeconds
@ -552,11 +545,11 @@ func TestOpenFiles(t *testing.T) {
pid := os.Getpid() pid := os.Getpid()
p, err := NewProcess(int32(pid)) p, err := NewProcess(int32(pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
v, err := p.OpenFiles() v, err := p.OpenFiles()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmpty(t, v) // test always open files. assert.NotEmpty(t, v) // test always open files.
@ -575,10 +568,10 @@ func TestKill(t *testing.T) {
require.NoError(t, cmd.Start()) require.NoError(t, cmd.Start())
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
err = p.Kill() err = p.Kill()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
cmd.Wait() cmd.Wait()
} }
@ -592,15 +585,15 @@ func TestIsRunning(t *testing.T) {
} }
cmd.Start() cmd.Start()
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
running, err := p.IsRunning() running, err := p.IsRunning()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "IsRunning error: %v", err) require.NoErrorf(t, err, "IsRunning error: %v", err)
require.Truef(t, running, "process should be found running") require.Truef(t, running, "process should be found running")
cmd.Wait() cmd.Wait()
running, err = p.IsRunning() running, err = p.IsRunning()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "IsRunning error: %v", err) require.NoErrorf(t, err, "IsRunning error: %v", err)
require.Falsef(t, running, "process should NOT be found running") require.Falsef(t, running, "process should NOT be found running")
} }
@ -632,11 +625,11 @@ func TestEnviron(t *testing.T) {
defer cmd.Process.Kill() defer cmd.Process.Kill()
time.Sleep(100 * time.Millisecond) time.Sleep(100 * time.Millisecond)
p, err := NewProcess(int32(cmd.Process.Pid)) p, err := NewProcess(int32(cmd.Process.Pid))
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
envs, err := p.Environ() envs, err := p.Environ()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting environ error %v", err) require.NoErrorf(t, err, "getting environ error %v", err)
var envvarFound bool var envvarFound bool
for _, envvar := range envs { for _, envvar := range envs {
@ -654,7 +647,7 @@ func TestCwd(t *testing.T) {
process, _ := NewProcess(int32(myPid)) process, _ := NewProcess(int32(myPid))
pidCwd, err := process.Cwd() pidCwd, err := process.Cwd()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoErrorf(t, err, "getting cwd error %v", err) require.NoErrorf(t, err, "getting cwd error %v", err)
pidCwd = strings.TrimSuffix(pidCwd, string(os.PathSeparator)) pidCwd = strings.TrimSuffix(pidCwd, string(os.PathSeparator))
assert.Equal(t, currentWorkingDirectory, pidCwd) assert.Equal(t, currentWorkingDirectory, pidCwd)

9
sensors/sensors_test.go
Unescape Escape View File

@ -3,7 +3,6 @@
package sensors package sensors
import ( import (
"errors"
"fmt" "fmt"
"os" "os"
"testing" "testing"
@ -25,18 +24,12 @@ func TestTemperatureStat_String(t *testing.T) {
assert.Equalf(t, s, fmt.Sprintf("%v", v), "TemperatureStat string is invalid, %v", fmt.Sprintf("%v", v)) assert.Equalf(t, s, fmt.Sprintf("%v", v), "TemperatureStat string is invalid, %v", fmt.Sprintf("%v", v))
} }
func skipIfNotImplementedErr(t *testing.T, err error) {
if errors.Is(err, common.ErrNotImplementedError) {
t.Skip("not implemented")
}
}
func TestTemperatures(t *testing.T) { func TestTemperatures(t *testing.T) {
if os.Getenv("CI") != "" { if os.Getenv("CI") != "" {
t.Skip("Skip CI") t.Skip("Skip CI")
} }
v, err := SensorsTemperatures() v, err := SensorsTemperatures()
skipIfNotImplementedErr(t, err) common.SkipIfNotImplementedErr(t, err)
require.NoError(t, err) require.NoError(t, err)
assert.NotEmptyf(t, v, "Could not get temperature %v", v) assert.NotEmptyf(t, v, "Could not get temperature %v", v)
t.Log(v) t.Log(v)

Write Preview
Loading…
Cancel
Save