Merge pull request #20 from gustavosbarreto/master

polling refactoring: remove initial state definition logic from PollState

main.go

@@ -9,7 +9,6 @@
 package main
 
 import (
-	"math/rand"
 	"os"
 	"time"
 
@@ -37,17 +36,17 @@ func main() {
 	}
 
 	uh := &UpdateHub{
-		state:               NewPollState(),
-		api:                 client.NewApiClient("localhost:8080"),
-		updater:             client.NewUpdateClient(),
-		timeStep:            time.Minute,
-		settings:            settings,
-		store:               afero.NewOsFs(),
-		pollingIntervalSpan: rand.Intn(settings.PollingInterval),
+		state:    NewPollState(),
+		api:      client.NewApiClient("localhost:8080"),
+		updater:  client.NewUpdateClient(),
+		timeStep: time.Minute,
+		settings: settings,
+		store:    afero.NewOsFs(),
 	}
 
 	uh.Controller = uh
 
+	uh.StartPolling()
 	uh.MainLoop()
 }
 

states.go

@@ -146,19 +146,6 @@ func (state *PollState) Handle(uh *UpdateHub) (State, bool) {
 	go func() {
 		pollingInterval := uh.settings.PollingInterval
 
-		now := time.Now()
-
-		if uh.settings.FirstPoll == 0 {
-			uh.settings.FirstPoll = int(now.Unix()) + uh.pollingIntervalSpan
-			pollingInterval = 1
-		}
-
-		if uh.settings.LastPoll == 0 && uh.settings.FirstPoll <= int(now.Unix()) {
-			nextState = NewUpdateCheckState()
-			state.Cancel(true)
-			return
-		}
-
 		for {
 			shouldPoll := int(time.Now().Unix()) > uh.settings.FirstPoll
 

states_test.go

@@ -200,63 +200,6 @@ func TestPollTicks(t *testing.T) {
 	}
 }
 
-func TestFirstPoll(t *testing.T) {
-	poll := NewPollState()
-	uh, err := newTestUpdateHub(poll)
-	assert.NoError(t, err)
-
-	now := time.Now()
-	count := -1
-	guard := monkey.Patch(time.Now, func() time.Time {
-		count++
-		if count == 0 {
-			return now
-		}
-		return now.Add(time.Second * time.Duration(count))
-	})
-	defer guard.Unpatch()
-
-	c := &testController{
-		updateAvailable: false,
-		extraPoll:       0,
-	}
-
-	uh.pollingIntervalSpan = 5
-	uh.settings.FirstPoll = 0
-	uh.settings.PollingInterval = 10
-
-	uh.Controller = c
-
-	nextState, _ := poll.Handle(uh)
-	assert.IsType(t, &UpdateCheckState{}, nextState)
-
-	assert.Equal(t, int(now.Unix())+uh.pollingIntervalSpan, uh.settings.FirstPoll)
-	assert.Equal(t, uh.pollingIntervalSpan, poll.ticksCount)
-}
-
-func TestDelayedPolling(t *testing.T) {
-	poll := NewPollState()
-	uh, err := newTestUpdateHub(poll)
-	assert.NoError(t, err)
-
-	now := time.Now()
-
-	c := &testController{
-		updateAvailable: false,
-		extraPoll:       0,
-	}
-
-	uh.settings.FirstPoll = int(now.Add(-1 * time.Second).Unix())
-	uh.settings.LastPoll = 0
-
-	uh.Controller = c
-
-	nextState, _ := poll.Handle(uh)
-	assert.IsType(t, &UpdateCheckState{}, nextState)
-
-	assert.Equal(t, 0, poll.ticksCount)
-}
-
 func TestPollingRetries(t *testing.T) {
 	uh, err := newTestUpdateHub(NewPollState())
 	assert.NoError(t, err)

updatehub.go

@@ -12,6 +12,7 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"math/rand"
 	"path"
 	"time"
 
@@ -33,7 +34,6 @@ type UpdateHub struct {
 	api                     *client.ApiClient
 	updater                 client.Updater
 	reporter                client.Reporter
-	pollingIntervalSpan     int
 	lastInstalledPackageUID string
 }
 
@@ -119,6 +119,24 @@ func (uh *UpdateHub) ReportCurrentState() error {
 	return nil
 }
 
+// StartPolling starts the polling process
+func (uh *UpdateHub) StartPolling() {
+	now := time.Now()
+
+	uh.state = NewPollState()
+
+	if uh.settings.FirstPoll == 0 {
+		// Apply an offset in first poll
+		uh.settings.FirstPoll = int(now.Add(time.Duration(rand.Intn(uh.settings.PollingInterval))).Unix())
+	} else if uh.settings.LastPoll == 0 && uh.settings.FirstPoll <= int(now.Unix()) {
+		// it never did a poll before
+		uh.state = NewUpdateCheckState()
+	} else if time.Unix(int64(uh.settings.LastPoll), 0).Add(time.Duration(uh.settings.PollingInterval)).Before(now) {
+		// pending regular interval
+		uh.state = NewUpdateCheckState()
+	}
+}
+
 func (uh *UpdateHub) MainLoop() {
 	for {
 		uh.ReportCurrentState()

updatehub_test.go

@@ -17,6 +17,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/bouk/monkey"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
 
@@ -127,6 +128,64 @@ func TestUpdateHubReportState(t *testing.T) {
 	assert.EqualError(t, err, "error")
 }
 
+func TestStartPolling(t *testing.T) {
+	now := time.Now()
+
+	// Simulate time passage from now
+	defer func() *monkey.PatchGuard {
+		seconds := -1
+		return monkey.Patch(time.Now, func() time.Time {
+			seconds++
+			return now.Add(time.Second * time.Duration(seconds))
+		})
+	}()
+
+	testCases := []struct {
+		name            string
+		pollingInterval time.Duration
+		firstPoll       int
+		lastPoll        int
+		expectedState   State
+	}{
+		{
+			"RegularPoll",
+			time.Second,
+			0,
+			0,
+			&PollState{},
+		},
+
+		{
+			"NeverDidPollBefore",
+			time.Second,
+			int(now.Add(-1 * time.Second).Unix()),
+			0,
+			&UpdateCheckState{},
+		},
+
+		{
+			"PendingRegularPoll",
+			time.Second,
+			int(now.Add(-2 * time.Second).Unix()),
+			int(now.Add(-1 * time.Second).Unix()),
+			&UpdateCheckState{},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			uh, _ := newTestUpdateHub(nil)
+
+			uh.settings.PollingInterval = int(tc.pollingInterval)
+			uh.settings.FirstPoll = tc.firstPoll
+			uh.settings.LastPoll = tc.lastPoll
+
+			uh.StartPolling()
+			assert.IsType(t, tc.expectedState, uh.state)
+		})
+	}
+}
+
 type testObject struct {
 	metadata.ObjectMetadata
 }