timeit: replace flag with alecthomas/kong, test with testscript and gotest.tools

testscript

sleepit

Author: marco-m

CHANGELOG.md

@@ -12,12 +12,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix [#1](https://github.com/marco-m/timeit/issues/1) as non reproducible. In any case, added manual test configuration in testdata/terraform.
 - Fix tests about signal handling. Code was already correct, but tests were not.
 
-### Changed, breaking
+### Breaking
+
+- due to the introduction of package kong to parse the command-line, now `timeit` wants flags specified with two hyphens, for example `--ticker` instead of `-ticker`. 
 
 ### Changed
 
-- Upgrade to Go 1.16
+- Upgrade to Go 1.19
 - Upgrade dependencies
+- Integration tests are now driven by package [rogpeppe/go-internal/testscript](http://github.com/rogpeppe/go-internal).
 
 ### New
 
@@ -43,7 +46,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
           Terminate immediately after N signals.
           Default is to terminate only when the cleanup phase has completed.
   ```
-- the sleepit helper now has also a good series of tests.
+- The sleepit helper now has also a good series of tests.
 - Add CI: build and test with GitHub Actions, for platforms: Linux, macOS, Windows.
 - Add basic and experimental support for Windows. Untested: signal handling.
 

README.md

@@ -28,15 +28,15 @@ example:
 
 Time a command and print intermediate timings (color output by default):
 
-    $ timeit -ticker 30s sleep 60
-    timeit ticker: running since 30.001s
-    timeit ticker: running since 1m0.004s
+    $ timeit --ticker 30s sleep 60
+    timeit ticker: running for 30s
+    timeit ticker: running for 1m
     timeit results:
     real: 1m0.005s
 
 Check online if there is a more recent version:
 
-    $ timeit -check-version
+    $ timeit --check-version
     installed version v0.2.1 is older than the latest version v0.3.0
     To upgrade visit https://github.com/marco-m/timeit
 

Taskfile.yml

@@ -7,7 +7,10 @@ vars:
     sh: git describe --long --dirty --always
   SHORT_VERSION:
     sh: git describe --abbrev=0 --always
-  LDFLAGS: -w -s -X main.fullVersion={{.FULL_VERSION}} -X main.shortVersion={{.SHORT_VERSION}}
+  LDFLAGS: >
+    -w -s
+    -X github.com/marco-m/timeit/pkg/timeit.fullVersion={{.FULL_VERSION}}
+    -X github.com/marco-m/timeit/pkg/timeit.shortVersion={{.SHORT_VERSION}}
 
 tasks:
   default:
@@ -23,8 +26,6 @@ tasks:
     dir: bin
     cmds:
       - go build -v -ldflags="{{.LDFLAGS}}" ../cmd/timeit
-    sources: [../cmd/timeit/*.go]
-    generates: [timeit]
   sleepit:
     desc: Build the sleepit executable
     dir: bin

cmd/sleepit/main.go

@@ -1,176 +1,14 @@
 // This code is released under the MIT License
-// Copyright (c) 2020 Marco Molteni and the timeit contributors.
+// Copyright (c) 2020-2023 Marco Molteni and the timeit contributors.
 
 package main
 
 import (
-	"flag"
-	"fmt"
 	"os"
-	"os/signal"
-	"time"
-)
-
-const usage = `sleepit: sleep for the specified duration, optionally handling signals
-When the line "sleepit: ready" is printed, it means that it is safe to send signals to it
-
-Usage: sleepit <command> [<args>]
 
-Commands
-
-  default     Use default action: on reception of SIGINT terminate abruptly
-  handle      Handle signals: on reception of SIGINT perform cleanup before exiting
-  version     Show the sleepit version`
-
-var (
-	// Filled by the linker.
-	fullVersion = "unknown" // example: v0.0.9-8-g941583d027-dirty
+	"github.com/marco-m/timeit/pkg/sleepit"
 )
 
 func main() {
-	os.Exit(run(os.Args[1:]))
-}
-
-func run(args []string) int {
-	if len(args) < 1 {
-		fmt.Fprintln(os.Stderr, usage)
-		return 2
-	}
-
-	defaultCmd := flag.NewFlagSet("default", flag.ExitOnError)
-	defaultSleep := defaultCmd.Duration("sleep", 5*time.Second, "Sleep duration")
-
-	handleCmd := flag.NewFlagSet("handle", flag.ExitOnError)
-	handleSleep := handleCmd.Duration("sleep", 5*time.Second, "Sleep duration")
-	handleCleanup := handleCmd.Duration("cleanup", 5*time.Second, "Cleanup duration")
-	handleTermAfter := handleCmd.Int("term-after", 0,
-		"Terminate immediately after `N` signals.\n"+
-			"Default is to terminate only when the cleanup phase has completed.")
-
-	versionCmd := flag.NewFlagSet("version", flag.ExitOnError)
-
-	switch args[0] {
-
-	case "default":
-		defaultCmd.Parse(args[1:])
-		if len(defaultCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "default: unexpected arguments: %v\n", defaultCmd.Args())
-			return 2
-		}
-		return supervisor(*defaultSleep, 0, 0, nil)
-
-	case "handle":
-		handleCmd.Parse(args[1:])
-		if *handleTermAfter == 1 {
-			fmt.Fprintf(os.Stderr, "handle: term-after cannot be 1\n")
-			return 2
-		}
-		if len(handleCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "handle: unexpected arguments: %v\n", handleCmd.Args())
-			return 2
-		}
-		sigCh := make(chan os.Signal, 1)
-		signal.Notify(sigCh, os.Interrupt) // Ctrl-C -> SIGINT
-		return supervisor(*handleSleep, *handleCleanup, *handleTermAfter, sigCh)
-
-	case "version":
-		versionCmd.Parse(args[1:])
-		if len(versionCmd.Args()) > 0 {
-			fmt.Fprintf(os.Stderr, "version: unexpected arguments: %v\n", versionCmd.Args())
-			return 2
-		}
-		fmt.Printf("sleepit version %s\n", fullVersion)
-		return 0
-
-	default:
-		fmt.Fprintln(os.Stderr, usage)
-		return 2
-	}
-}
-
-func supervisor(
-	sleep time.Duration,
-	cleanup time.Duration,
-	termAfter int,
-	sigCh <-chan os.Signal,
-) int {
-	fmt.Printf("sleepit: ready\n")
-	fmt.Printf("sleepit: PID=%d sleep=%v cleanup=%v\n",
-		os.Getpid(), sleep, cleanup)
-
-	cancelWork := make(chan struct{})
-	workerDone := worker(cancelWork, sleep, "work")
-
-	cancelCleaner := make(chan struct{})
-	var cleanerDone <-chan struct{}
-
-	sigCount := 0
-	for {
-		select {
-		case sig := <-sigCh:
-			sigCount++
-			fmt.Printf("sleepit: got signal=%s count=%d\n", sig, sigCount)
-			if sigCount == 1 {
-				// since `cancelWork` is unbuffered, sending will be synchronous:
-				// we are ensured that the worker has terminated before starting cleanup.
-				// This is important in some real-life situations.
-				cancelWork <- struct{}{}
-				cleanerDone = worker(cancelCleaner, cleanup, "cleanup")
-			}
-			if sigCount == termAfter {
-				cancelCleaner <- struct{}{}
-				return 4
-			}
-		case <-workerDone:
-			return 0
-		case <-cleanerDone:
-			return 3
-		}
-	}
-}
-
-// Start a worker goroutine and return immediately a `workerDone` channel.
-// The goroutine will prepend its prints with the prefix `name`.
-// The goroutine will simulate some work and will terminate when one of the following
-// conditions happens:
-//  1. When `howlong` is elapsed. This case will be signaled on the `workerDone` channel.
-//  2. When something happens on channel `canceled`. Note that this simulates real-life,
-//     so cancellation is not instantaneous: if the caller wants a synchronous cancel,
-//     it should send a message; if instead it wants an asynchronous cancel, it should
-//     close the channel.
-func worker(
-	canceled <-chan struct{},
-	howlong time.Duration,
-	name string,
-) <-chan struct{} {
-	workerDone := make(chan struct{})
-	deadline := time.Now().Add(howlong)
-	go func() {
-		fmt.Printf("sleepit: %s started\n", name)
-		for {
-			select {
-			case <-canceled:
-				fmt.Printf("sleepit: %s canceled\n", name)
-				return
-			default:
-				if doSomeWork(deadline) {
-					fmt.Printf("sleepit: %s done\n", name) // <== NOTE THIS LINE
-					workerDone <- struct{}{}
-					return
-				}
-			}
-		}
-	}()
-	return workerDone
-}
-
-// Do some work and then return, so that the caller can decide wether to continue or not.
-// Return true when all work is done.
-func doSomeWork(deadline time.Time) bool {
-	if time.Now().After(deadline) {
-		return true
-	}
-	timeout := 100 * time.Millisecond
-	time.Sleep(timeout)
-	return false
+	os.Exit(sleepit.Main())
 }