Refactor towards a process (#7)

- Removed all implementation related to output messages and replaced by a `RegisterAnPollProcess` type
- Renamed param _delay_ by _sec_  in CLI command `./timehook -sec`

Author: martinezdelariva

README.md

@@ -6,6 +6,10 @@ Timehook CLI client is a client implementation to use with [https://api.timehook
 
 ## Usage
 
+##### Use executable (recommended)
+
+Download at [releases](https://github.com/timehook/cli-client/releases)
+
 ##### Compile on your own
 
 1. Download or clone the repo.
@@ -24,7 +28,7 @@ With defaults:
 
 With custom values:
 
-    ./bin/timehook --delay 11 --url https://your-url.com body --body '{"bar" : "bar"}'
+    ./bin/timehook --sec 11 --url https://your-url.com body --body '{"bar" : "bar"}'
       
       
 For further info:

cmd/main/timehook.go

@@ -13,7 +13,7 @@ import (
 func main() {
 	URL := flag.String("url", "https://httpstat.us/200", "webhook URL")
 	body := flag.String("body", `{"msg" : "from timehook client"}`, "webhook body in JSON")
-	delay := flag.Int("delay", 5, "delay in seconds")
+	sec := flag.Int("sec", 5, "delay in seconds")
 	flag.Parse()
 
 	if os.Getenv("TIMEHOOK_KEY") == "" {
@@ -22,18 +22,13 @@ func main() {
 	}
 
 	client := timehook.New(os.Getenv("TIMEHOOK_KEY"), http.DefaultClient)
-	out, errc, succ := client.RegisterAndPoll(*URL, *body, *delay, 1*time.Second)
-	for {
-		select {
-		case msg := <-out:
-			fmt.Fprint(os.Stdout, msg)
-		case msg := <-errc:
-			fmt.Fprint(os.Stderr, msg)
-		case isSucc := <-succ:
-			if isSucc {
-				os.Exit(0)
-			}
-			os.Exit(1)
-		}
+	proc := client.RegisterAndPoll(*URL, *body, *sec, 1*time.Second)
+	for msg := range proc.C {
+		fmt.Fprint(os.Stdout, msg)
 	}
+
+	if proc.IsSucceeded() {
+		os.Exit(0)
+	}
+	os.Exit(1)
 }

timehook/client.go

@@ -41,8 +41,8 @@ type StateResponse struct {
 }
 
 var (
-	errTooManyRequests = errors.New("server responses 429 too many request")
-	errUnauthorized    = errors.New("server responses 401 unauthorized request")
+	ErrTooManyRequests = errors.New("server responses 429 too many request")
+	ErrUnauthorized    = errors.New("server responses 401 unauthorized request")
 )
 
 // client exposes the functions allowed to talk with the Timehook API
@@ -52,29 +52,19 @@ type client struct {
 }
 
 // RegisterAndPoll starts a long running process for a single webhook and
-// returns three channels: first one for regular messages, second one for
-// errors and third one indicates in the overall process was successful.
+// returns RegisterAnPollProcess which can be query to know the process.
 //
 // The process consists in first registers the webhook to be execute on URL
 // with the body given with a delay in seconds.
 // Second it polls the state until it the webhook finishes or until encounter
 // an irrecoverable error.
-func (c *client) RegisterAndPoll(URL, body string, delay int, interval time.Duration) (<-chan string, <-chan string, <-chan bool) {
-	out := make(chan string)
-	errc := make(chan string)
-	succ := make(chan bool)
-
+func (c *client) RegisterAndPoll(URL, body string, sec int, interval time.Duration) *RegisterAnPollProcess {
+	proc := NewRegisterAnPollProcess()
 	go func() {
-		defer close(out)
-		defer close(errc)
-		defer close(succ)
-		stdout := NewOutput()
-
-		out <- stdout.Connecting()
-		rr, err := c.register(URL, body, delay)
+		proc.Connect()
+		rr, err := c.register(URL, body, sec)
 		if err != nil {
-			errc <- stdout.Error(err)
-			succ <- false
+			proc.Error(err)
 			return
 		}
 
@@ -83,21 +73,18 @@ func (c *client) RegisterAndPoll(URL, body string, delay int, interval time.Dura
 		for range ticker.C {
 			sr, err := c.state(rr.ID)
 			if err != nil {
-				errc <- stdout.Error(err)
+				proc.Error(err)
 			} else {
-				for _, v := range stdout.State(sr) {
-					out <- v
-				}
+				proc.State(sr)
 			}
 
-			if isFinal(sr, err) {
-				succ <- isSuccess(sr, err)
+			if proc.IsFinished() {
 				break
 			}
 		}
 	}()
 
-	return out, errc, succ
+	return proc
 }
 
 // isFinal returns if StateResponse or err is a final state
@@ -106,7 +93,7 @@ func isFinal(state *StateResponse, err error) bool {
 		return state.Status == "failed" || state.Status == "succeeded" || state.Status == "timeout"
 	}
 
-	if err == errUnauthorized {
+	if err == ErrUnauthorized {
 		return true
 	}
 
@@ -180,9 +167,9 @@ func (c *client) execute(req *http.Request, codeWanted int) ([]byte, error) {
 
 	switch c := resp.StatusCode; {
 	case c == 401:
-		return nil, errUnauthorized
+		return nil, ErrUnauthorized
 	case c == 429:
-		return nil, errTooManyRequests
+		return nil, ErrTooManyRequests
 	case c != codeWanted:
 		return nil, fmt.Errorf("wrong response registering webhook: %s, %s\n", resp.Status, b)
 	}

timehook/client_test.go

@@ -1,123 +1,14 @@
 package timehook_test
 
 import (
+	"io/ioutil"
 	"testing"
 	"time"
 
-	"errors"
-
-	"io/ioutil"
-
 	"github.com/timehook/cli-client/mock"
 	"github.com/timehook/cli-client/timehook"
 )
 
-func TestRegisterAndPoll_Channels(t *testing.T) {
-	tt := []struct {
-		name          string
-		httpResponses []interface{}
-		outWanted     int
-		errWanted     int
-		succWanted    bool
-	}{
-		{
-			name: "happy path",
-			httpResponses: []interface{}{
-				mock.RegisteredSuccess(),
-				mock.StateRegistered(),
-				mock.StateAwaiting(),
-				mock.StateSending(),
-				mock.StateSucceeded(),
-			},
-			outWanted:  5,
-			errWanted:  0,
-			succWanted: true,
-		},
-		{
-			name: "succeeded with error querying state",
-			httpResponses: []interface{}{
-				mock.RegisteredSuccess(),
-				mock.StateRegistered(),
-				errors.New("some error"),
-				mock.StateAwaiting(),
-				mock.StateSending(),
-				mock.StateSucceeded(),
-			},
-			outWanted:  5,
-			errWanted:  1,
-			succWanted: true,
-		},
-		{
-			name: "not succeeded with unauthorized error",
-			httpResponses: []interface{}{
-				mock.Unauthorized(),
-			},
-			outWanted:  1,
-			errWanted:  1,
-			succWanted: false,
-		},
-		{
-			name: "not succeeded with failed webhook",
-			httpResponses: []interface{}{
-				mock.RegisteredSuccess(),
-				mock.StateRegistered(),
-				mock.StateAwaiting(),
-				mock.StateSending(),
-				mock.StateFailed(),
-			},
-			outWanted:  5,
-			errWanted:  0,
-			succWanted: false,
-		},
-		{
-			name: "succeeded with 429 too many requests",
-			httpResponses: []interface{}{
-				mock.RegisteredSuccess(),
-				mock.StateRegistered(),
-				mock.StateAwaiting(),
-				mock.TooManyRequest429(),
-				mock.StateSending(),
-				mock.StateFailed(),
-			},
-			outWanted:  5,
-			errWanted:  1,
-			succWanted: false,
-		},
-	}
-
-	for _, v := range tt {
-		t.Run(v.name, func(t *testing.T) {
-			client := timehook.New("api-key", mock.HTTPClient(v.httpResponses))
-			out, errc, succ := client.RegisterAndPoll("https://the-domain.com", `{"foo" : "bar"}`, 5, 1*time.Nanosecond)
-			timeC := time.After(1 * time.Second)
-			var outN, errN int
-		loop:
-			for {
-				select {
-				case <-out:
-					outN++
-				case <-errc:
-					errN++
-				case isSucc := <-succ:
-					if isSucc != v.succWanted {
-						t.Errorf("wrong succ, got %v want %v", isSucc, v.succWanted)
-					}
-					break loop
-				case <-timeC:
-					t.Errorf("no message receive in succ channel")
-				}
-			}
-
-			if outN != v.outWanted {
-				t.Errorf("wrong number of out messages, want %d got %d", v.outWanted, outN)
-			}
-			if errN != v.errWanted {
-				t.Errorf("wrong number of err messages, want %d got %d", v.errWanted, errN)
-			}
-		})
-	}
-}
-
 func TestRegisterAndPoll_HTTPRequest(t *testing.T) {
 	// given
 	HTTPClient := mock.HTTPClient([]interface{}{
@@ -130,15 +21,8 @@ func TestRegisterAndPoll_HTTPRequest(t *testing.T) {
 	client := timehook.New("api-key", HTTPClient)
 
 	// when
-	out, errc, succ := client.RegisterAndPoll("https://the-domain.com", `{"foo" : "bar"}`, 5, 1*time.Nanosecond)
-loop:
-	for {
-		select {
-		case <-out:
-		case <-errc:
-		case <-succ:
-			break loop
-		}
+	proc := client.RegisterAndPoll("https://the-domain.com", `{"foo" : "bar"}`, 5, 1*time.Nanosecond)
+	for range proc.C {
 	}
 
 	// then register