Working test with mocks

Author: mattolenik

cmd/root.go

@@ -35,10 +35,11 @@ For example:
 		if err != nil {
 			return errors.Annotatef(err, "failed to configure DDNS provider")
 		}
+		daemon := ddns.NewDDNSDaemon(provider, ddns.NewDefaultIPProvider(), ddns.NewDefaultConfigProvider())
 		if conf.Daemon.Get() {
-			return errors.Trace(ddns.StartWithDefaults(provider))
+			return errors.Trace(daemon.StartWithDefaults())
 		}
-		return errors.Trace(ddns.Update(provider))
+		return errors.Trace(daemon.Update())
 	},
 	Version: meta.Version,
 }

ddns/ddns.go

@@ -20,26 +20,34 @@ type IPProvider interface {
 	Get() (ip string, err error)
 }
 
-type ConfigProvider interface {
-	Get() (domain, record string, err error)
-}
+type DefaultIPProvider struct{}
 
-type ipProvider struct{}
-
-func (p *ipProvider) Get() (string, error) {
+func (p *DefaultIPProvider) Get() (string, error) {
 	ip, err := ip.GetPublicIPWithRetry(10, 5*time.Second)
 	if err != nil {
 		return "", errors.Trace(err)
 	}
 	return ip, nil
 }
 
-type configProvider struct{}
+func NewDefaultIPProvider() *DefaultIPProvider {
+	return &DefaultIPProvider{}
+}
+
+type ConfigProvider interface {
+	Get() (domain, record string, err error)
+}
 
-func (p *configProvider) Get() (domain, record string, err error) {
+type DefaultConfigProvider struct{}
+
+func (p *DefaultConfigProvider) Get() (domain, record string, err error) {
 	return conf.Domain.Get(), conf.Record.Get(), nil
 }
 
+func NewDefaultConfigProvider() *DefaultConfigProvider {
+	return &DefaultConfigProvider{}
+}
+
 type Daemon interface {
 	Update(provider DDNSProvider) error
 	Start(provider DDNSProvider, updatePeriod, failureRetryDelay time.Duration) error
@@ -150,7 +158,7 @@ func (d *DDNSDaemon) Start(updatePeriod, failureRetryDelay time.Duration) error
 }
 
 // StartWithDefaults calls Start but with default values
-func (d *DDNSDaemon) StartWithDefaults(provider DDNSProvider) error {
+func (d *DDNSDaemon) StartWithDefaults() error {
 	t := 10 * time.Second
 	return errors.Trace(d.Start(t, t))
 }

ddns/ddns_test.go

@@ -4,22 +4,29 @@ import (
 	"testing"
 
 	"github.com/golang/mock/gomock"
-	"github.com/stretchr/testify/assert"
+	"github.com/mattolenik/cloudflare-ddns-client/test"
 )
 
 func TestDDNSDaemon(t *testing.T) {
-	assert := assert.New(t)
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	d := NewMockDaemon(ctrl)
-	p := NewMockDDNSProvider(ctrl)
+	assert, _, ctrl, cleanup := test.NewTools(t)
+	defer cleanup()
+
 	domain := "abc.com"
 	record := "xyz.abc.com"
-	ip := "1.1.1.1"
-	p.EXPECT().Update(gomock.Eq(domain), gomock.Eq(record), gomock.Eq(ip)).Return(nil).Times(1)
-	p.EXPECT().Get(domain, record).Return(ip, nil).Times(1)
-	assert.NoError(d.Update(p))
-	ip, err := p.Get(domain)
+	expectedIP := "1.1.1.1"
+
+	ddnsProvider := NewMockDDNSProvider(ctrl)
+	ipProvider := NewMockIPProvider(ctrl)
+	configProvider := NewMockConfigProvider(ctrl)
+	ddnsDaemon := NewDDNSDaemon(ddnsProvider, ipProvider, configProvider)
+
+	configProvider.EXPECT().Get().Return(domain, record, nil)
+	ipProvider.EXPECT().Get().Return(expectedIP, nil)
+	ddnsProvider.EXPECT().Update(gomock.Eq(domain), gomock.Eq(record), gomock.Eq(expectedIP)).Return(nil).Times(1)
+	ddnsProvider.EXPECT().Get(domain, record).Return(expectedIP, nil).Times(1)
+	assert.NoError(ddnsDaemon.Update())
+
+	actualIP, err := ddnsProvider.Get(domain, record)
 	assert.NoError(err)
-	assert.Equal(ip, ip)
+	assert.Equal(expectedIP, actualIP)
 }

ddns/mocks.go

@@ -0,0 +1,15 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// NewTools creates new instances of common testing tools
+func NewTools(t *testing.T) (asrt *assert.Assertions, req *require.Assertions, controller *gomock.Controller, cleanup func()) {
+	ctrl := gomock.NewController(t)
+	return assert.New(t), require.New(t), ctrl, ctrl.Finish
+}