refactor unit tests on package lock

lock/lock_test.go

@@ -8,42 +8,51 @@ import (
 	"os/signal"
 	"path/filepath"
 	"regexp"
-	"runtime"
 	"syscall"
 	"testing"
 	"time"
 
+	"github.com/creativeprojects/resticprofile/platform"
 	"github.com/creativeprojects/resticprofile/shell"
 	"github.com/shirou/gopsutil/v3/process"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-const (
+var (
 	helperBinary = "./locktest"
 )
 
 func init() {
-	if runtime.GOOS == "windows" {
-		return
+	if platform.IsWindows() {
+		helperBinary += ".exe"
 	}
-	// compile helper command
 	cmd := exec.Command("go", "build", "-o", helperBinary, "./test")
 	cmd.Run()
 }
 
-func TestLockIsAvailable(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestLockIsAvailable", time.Now().UnixNano(), os.Getpid()))
+func getTempfile(t *testing.T) string {
+	t.Helper()
+
+	tempfile := filepath.Join(t.TempDir(), fmt.Sprintf("%s.tmp", t.Name()))
 	t.Log("Using temporary file", tempfile)
+	return tempfile
+}
+
+func TestLockIsAvailable(t *testing.T) {
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
 	assert.True(t, lock.TryAcquire())
 }
 
 func TestLockIsNotAvailable(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestLockIsNotAvailable", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
@@ -62,8 +71,9 @@ func TestLockIsNotAvailable(t *testing.T) {
 }
 
 func TestNoPID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestNoPID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 	lock.TryAcquire()
@@ -77,8 +87,9 @@ func TestNoPID(t *testing.T) {
 }
 
 func TestSetOnePID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestSetPID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 	lock.TryAcquire()
@@ -93,8 +104,9 @@ func TestSetOnePID(t *testing.T) {
 }
 
 func TestSetMorePID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestSetMorePID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 	lock.TryAcquire()
@@ -110,8 +122,9 @@ func TestSetMorePID(t *testing.T) {
 	assert.Equal(t, int32(13), pid)
 }
 
-// This test is using the shell package. This is just a convenient wrapper around cmd.exe and sh
 func TestProcessFinished(t *testing.T) {
+	t.Parallel()
+
 	childPID := 0
 	buffer := &bytes.Buffer{}
 
@@ -135,27 +148,18 @@ func TestProcessFinished(t *testing.T) {
 	assert.False(t, running)
 }
 
-// This test is using the shell package. This is just a convenient wrapper around cmd.exe and sh
 func TestProcessNotFinished(t *testing.T) {
+	t.Parallel()
+
 	childPID := 0
 	buffer := &bytes.Buffer{}
 
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt)
 	defer signal.Reset(os.Interrupt)
 
-	// use ping to make sure the process is running for long enough to check its existence
-	var parameters []string
-	if runtime.GOOS == "windows" {
-		// it will run for 1 second
-		parameters = []string{"-n", "2", "127.0.0.1"}
-	} else {
-		// run for 200ms (don't need a whole second)
-		// 0.2 is the minimum in linux, 0.1 in darwin
-		parameters = []string{"-c", "2", "-i", "0.2", "127.0.0.1"}
-	}
-
-	cmd := shell.NewSignalledCommand("ping", parameters, c)
+	// user the lock helper binary (we only need to wait for some time, we don't need the locking part)
+	cmd := shell.NewSignalledCommand(helperBinary, []string{"-wait", "100", "-lock", t.Name()}, c)
 	cmd.Stdout = buffer
 	// SetPID method is called right after we forked and have a PID available
 	cmd.SetPID = func(pid int) {
@@ -165,9 +169,7 @@ func TestProcessNotFinished(t *testing.T) {
 		assert.True(t, running)
 	}
 	_, _, err := cmd.Run()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	// at that point, the child process should be finished
 	running, err := process.PidExists(int32(childPID))
@@ -176,17 +178,19 @@ func TestProcessNotFinished(t *testing.T) {
 }
 
 func TestForceLockIsAvailable(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestForceLockIsAvailable", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
 	assert.True(t, lock.ForceAcquire())
 }
 
 func TestForceLockWithNoPID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestForceLockWithNoPID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
@@ -199,10 +203,10 @@ func TestForceLockWithNoPID(t *testing.T) {
 	assert.False(t, other.HasLocked())
 }
 
-// This test is using the shell package. This is just a convenient wrapper around cmd.exe and sh
 func TestForceLockWithExpiredPID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestForceLockWithExpiredPID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
@@ -230,10 +234,10 @@ func TestForceLockWithExpiredPID(t *testing.T) {
 	assert.True(t, other.HasLocked())
 }
 
-// This test is using the shell package. This is just a convenient wrapper around cmd.exe and sh
 func TestForceLockWithRunningPID(t *testing.T) {
-	tempfile := filepath.Join(os.TempDir(), fmt.Sprintf("%s%d%d.tmp", "TestForceLockWithRunningPID", time.Now().UnixNano(), os.Getpid()))
-	t.Log("Using temporary file", tempfile)
+	t.Parallel()
+
+	tempfile := getTempfile(t)
 	lock := NewLock(tempfile)
 	defer lock.Release()
 
@@ -245,18 +249,8 @@ func TestForceLockWithRunningPID(t *testing.T) {
 	signal.Notify(c, os.Interrupt)
 	defer signal.Reset(os.Interrupt)
 
-	// use ping to make sure the process is running for long enough to check its existence
-	var parameters []string
-	if runtime.GOOS == "windows" {
-		// it will run for 1 second
-		parameters = []string{"-n", "2", "127.0.0.1"}
-	} else {
-		// run for 200ms (don't need a whole second)
-		// 0.2 is the minimum in linux, 0.1 in darwin
-		parameters = []string{"-c", "2", "-i", "0.2", "127.0.0.1"}
-	}
-
-	cmd := shell.NewSignalledCommand("ping", parameters, c)
+	// user the lock helper binary (we only need to wait for some time, we don't need the locking part)
+	cmd := shell.NewSignalledCommand(helperBinary, []string{"-wait", "100", "-lock", t.Name()}, c)
 	cmd.SetPID = func(pid int) {
 		lock.SetPID(pid)
 		// make sure we cannot break the lock right now
@@ -266,18 +260,16 @@ func TestForceLockWithRunningPID(t *testing.T) {
 		assert.False(t, other.HasLocked())
 	}
 	_, _, err := cmd.Run()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 }
 
 func TestLockWithNoInterruption(t *testing.T) {
-	if runtime.GOOS == "windows" {
+	t.Parallel()
+
+	if platform.IsWindows() {
 		t.Skip("cannot send a signal to a child process in Windows")
 	}
-	lockfile := "TestLockWithNoInterruption.lock"
-	// make sure there's no remaining lockfile from a failed test
-	_ = os.Remove(lockfile)
+	lockfile := getTempfile(t)
 
 	var err error
 	buffer := &bytes.Buffer{}
@@ -291,12 +283,12 @@ func TestLockWithNoInterruption(t *testing.T) {
 }
 
 func TestLockIsRemovedAfterInterruptSignal(t *testing.T) {
-	if runtime.GOOS == "windows" {
+	t.Parallel()
+
+	if platform.IsWindows() {
 		t.Skip("cannot send a signal to a child process in Windows")
 	}
-	lockfile := "TestLockIsRemovedAfterInterruptSignal.lock"
-	// make sure there's no remaining lockfile from a failed test
-	_ = os.Remove(lockfile)
+	lockfile := getTempfile(t)
 
 	var err error
 	buffer := &bytes.Buffer{}
@@ -317,12 +309,12 @@ func TestLockIsRemovedAfterInterruptSignal(t *testing.T) {
 }
 
 func TestLockIsRemovedAfterInterruptSignalInsideShell(t *testing.T) {
-	if runtime.GOOS == "windows" {
+	t.Parallel()
+
+	if platform.IsWindows() {
 		t.Skip("cannot send a signal to a child process in Windows")
 	}
-	lockfile := "TestLockIsRemovedAfterInterruptSignal.lock"
-	// make sure there's no remaining lockfile from a failed test
-	_ = os.Remove(lockfile)
+	lockfile := getTempfile(t)
 
 	var err error
 	buffer := &bytes.Buffer{}