BDDish test experimentation

Author: mattolenik

cmd/root.go

@@ -46,29 +46,6 @@ For example:
 	Version: meta.Version,
 }
 
-func runDaemon(provider ddns.DDNSProvider, daemon *ddns.DDNSDaemon) error {
-	statusChan := daemon.StartWithDefaults()
-	for {
-		select {
-		case status := <-statusChan:
-			switch status.Type {
-			case task.Info:
-				log.Info().Msg(status.Message)
-			case task.Error:
-				log.Error().Msg(status.Message)
-			case task.Fatal:
-				log.Error().Msg("FATAL: " + status.Message)
-				return status.Error
-			}
-			if status.IsDone {
-				return nil
-			}
-		default:
-			time.Sleep(1 * time.Second)
-		}
-	}
-}
-
 func init() {
 	if path, err := os.Executable(); err == nil {
 		meta.ProgramDir = filepath.Dir(path)
@@ -124,3 +101,26 @@ func initConfig() {
 		errhandler.Handle(err)
 	}
 }
+
+func runDaemon(provider ddns.DDNSProvider, daemon *ddns.DDNSDaemon) error {
+	statusChan := daemon.StartWithDefaults()
+	for {
+		select {
+		case status := <-statusChan:
+			switch status.Type {
+			case task.Info:
+				log.Info().Msg(status.Message)
+			case task.Error:
+				log.Error().Msg(status.Message)
+			case task.Fatal:
+				log.Error().Msg("FATAL: " + status.Message)
+				return status.Error
+			}
+			if status.IsDone {
+				return nil
+			}
+		default:
+			time.Sleep(1 * time.Second)
+		}
+	}
+}

ddns/ddns.go

@@ -96,8 +96,8 @@ func (d *DDNSDaemon) Update() error {
 }
 
 // Start continually keeps DDNS up to date.
-// updatePeriod      - how often to check for updates
-// failureRetryDelay - how long to wait until retry after a failure
+// updatePeriod - how often to check for updates
+// retryDelay   - how long to wait until retry after a failure
 func (d *DDNSDaemon) Start(updatePeriod, retryDelay time.Duration) (status chan task.Status) {
 	var lastIP string
 	var lastIPUpdate time.Time

ddns/ddns_test.go

@@ -6,7 +6,10 @@ import (
 	"time"
 
 	"github.com/golang/mock/gomock"
+	"github.com/mattolenik/cloudflare-ddns-client/ddns"
 	"github.com/mattolenik/cloudflare-ddns-client/test"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestUpdate(t *testing.T) {
@@ -33,10 +36,35 @@ func TestUpdate(t *testing.T) {
 	assert.Equal(ip, actualIP)
 }
 
+type TestFlow struct {
+	t           *testing.T
+	assert      *assert.Assertions
+	require     *require.Assertions
+	description string
+}
+
+func It(t *testing.T, desc string) *TestFlow {
+	return &TestFlow{
+		description: desc,
+		t:           t,
+		assert:      assert.New(t),
+		require:     require.New(t),
+	}
+}
+
+// TODO: Make generic so should funcs can take any function type? Make not dependent upon testify if possible
+type ShouldFunc func(t *testing.T, assert *assert.Assertions, require *require.Assertions)
+
+func (f *TestFlow) Should(msg string, fn ShouldFunc) *TestFlow {
+	f.t.Run(fmt.Sprintf("It '%s' should '%s'", f.description, msg), func(t *testing.T) { fn(f.t, f.assert, f.require) })
+	return f
+}
+
 func TestDaemon(t *testing.T) {
-	assert, _, ctrl, cleanup := test.NewTools(t)
-	defer cleanup()
+	daemon := It(t, "daemon")
 
+	updatePeriod := 50 * time.Millisecond
+	retryDelay := 50 * time.Millisecond
 	domain := "abc.com"
 	record := "xyz.abc.com"
 	currentSuffix := 0
@@ -46,26 +74,33 @@ func TestDaemon(t *testing.T) {
 		currentIP = fmt.Sprintf("1.1.1.%d", currentSuffix)
 		return currentIP, nil
 	}
-	getCurrentIP := func() interface{} { return currentIP }
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	ddnsProvider, ipProvider, configProvider := fixtures(ctrl)
+	ddnsDaemon := ddns.NewDefaultDaemon(ddnsProvider, ipProvider, configProvider)
 
-	ddnsProvider := NewMockDDNSProvider(ctrl)
-	ipProvider := NewMockIPProvider(ctrl)
-	configProvider := NewMockConfigProvider(ctrl)
-	ddnsDaemon := NewDefaultDaemon(ddnsProvider, ipProvider, configProvider)
-	updatePeriod := 50 * time.Millisecond
-	retryDelay := 50 * time.Millisecond
-	ddnsDaemon.Start(updatePeriod, retryDelay)
+	daemon.Should("run", func(t *testing.T, assert *assert.Assertions, require *require.Assertions) {
+		getCurrentIP := func() interface{} { return currentIP }
 
-	configProvider.EXPECT().Get().Return(domain, record, nil)
-	ipProvider.EXPECT().Get().DoAndReturn(ipGen)
-	//ddnsProvider.EXPECT().Update(gomock.Eq(domain), gomock.Eq(record), gomock.Eq(ip)).Return(nil).Times(1)
-	//ddnsProvider.EXPECT().Get(domain, record).Return(ip, nil).Times(1)
-	ddnsProvider.EXPECT().
-		Update(
-			gomock.Eq(domain),
-			gomock.Eq(record),
-			FnMatch(gomock.Eq, getCurrentIP),
-		).AnyTimes()
+		ddnsDaemon.Start(updatePeriod, retryDelay)
+
+		configProvider.EXPECT().Get().Return(domain, record, nil)
+		ipProvider.EXPECT().Get().DoAndReturn(ipGen)
+		//ddnsProvider.EXPECT().Update(gomock.Eq(domain), gomock.Eq(record), gomock.Eq(ip)).Return(nil).Times(1)
+		//ddnsProvider.EXPECT().Get(domain, record).Return(ip, nil).Times(1)
+		ddnsProvider.EXPECT().
+			Update(
+				gomock.Eq(domain),
+				gomock.Eq(record),
+				FnMatch(gomock.Eq, getCurrentIP),
+			).AnyTimes()
+	})
+}
+
+func fixtures(ctrl *gomock.Controller) (ddnsProvider *MockDDNSProvider, ipProvider *MockIPProvider, configProvider *MockConfigProvider) {
+	return NewMockDDNSProvider(ctrl),
+		NewMockIPProvider(ctrl),
+		NewMockConfigProvider(ctrl)
 }
 
 type funcMatcher struct {