Refactor and test creation of moduler instances

metricbeat/helper/metricset_test.go

@@ -49,7 +49,7 @@ type MockMetricSeter struct {
 }
 
 func (m *MockMetricSeter) Fetch(ms *MetricSet) (events []common.MapStr, err error) {
-	m.counter = m.counter + 1
+	m.counter += 1
 
 	event := common.MapStr{
 		"counter": m.counter,

metricbeat/helper/module.go

@@ -36,7 +36,7 @@ type Module struct {
 }
 
 // NewModule creates a new module
-func NewModule(cfg *ucfg.Config, moduler Moduler) (*Module, error) {
+func NewModule(cfg *ucfg.Config, moduler func() Moduler) (*Module, error) {
 
 	// Module config defaults
 	config := ModuleConfig{
@@ -52,7 +52,7 @@ func NewModule(cfg *ucfg.Config, moduler Moduler) (*Module, error) {
 		name:       config.Module,
 		Config:     config,
 		cfg:        cfg,
-		moduler:    moduler,
+		moduler:    moduler(),
 		metricSets: map[string]*MetricSet{},
 		wg:         sync.WaitGroup{},
 		done:       make(chan struct{}),

metricbeat/helper/module_test.go

@@ -4,6 +4,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/urso/ucfg"
+	"reflect"
 )
 
 func TestGetMetricSetsList(t *testing.T) {
@@ -19,3 +21,48 @@ func TestGetMetricSetsList(t *testing.T) {
 	assert.Equal(t, "test1, test2", module.getMetricSetsList())
 
 }
+
+func TestNewModule(t *testing.T) {
+
+	config, _ := ucfg.NewFrom(ModuleConfig{
+		Module: "test",
+	})
+
+	module, err := NewModule(config, NewMockModuler)
+	assert.NoError(t, err)
+	assert.NotNil(t, module)
+
+	err = module.moduler.Setup(config)
+	assert.NoError(t, err)
+}
+
+// Check that the moduler inside each module is a different instance
+func TestNewModulerDifferentInstance(t *testing.T) {
+
+	config, _ := ucfg.NewFrom(ModuleConfig{
+		Module: "test",
+	})
+
+	module1, err := NewModule(config, NewMockModuler)
+	assert.NoError(t, err)
+	module2, err := NewModule(config, NewMockModuler)
+	assert.NoError(t, err)
+
+	module1.moduler.Setup(config)
+	assert.False(t, reflect.DeepEqual(module1.moduler, module2.moduler))
+	assert.True(t, reflect.DeepEqual(module1.moduler, module1.moduler))
+}
+
+// New creates new instance of Moduler
+func NewMockModuler() Moduler {
+	return &MockModuler{}
+}
+
+type MockModuler struct {
+	counter int
+}
+
+func (m *MockModuler) Setup(cfg *ucfg.Config) error {
+	m.counter += 1
+	return nil
+}

metricbeat/helper/register.go

@@ -18,15 +18,15 @@ import (
 var Registry = Register{}
 
 type Register struct {
-	Modulers     map[string]Moduler
+	Modulers     map[string]func() Moduler
 	MetricSeters map[string]map[string]func() MetricSeter
 }
 
 // AddModule registers the given module with the registry
-func (r *Register) AddModuler(name string, m Moduler) {
+func (r *Register) AddModuler(name string, m func() Moduler) {
 
 	if r.Modulers == nil {
-		r.Modulers = map[string]Moduler{}
+		r.Modulers = map[string]func() Moduler{}
 	}
 
 	logp.Info("Register module: %s", name)

metricbeat/module/apache/apache.go

@@ -9,7 +9,12 @@ import (
 )
 
 func init() {
-	helper.Registry.AddModuler("apache", Moduler{})
+	helper.Registry.AddModuler("apache", New)
+}
+
+// New creates new instance of Moduler
+func New() helper.Moduler {
+	return &Moduler{}
 }
 
 type Moduler struct{}

metricbeat/module/mysql/mysql.go

@@ -11,7 +11,12 @@ import (
 )
 
 func init() {
-	helper.Registry.AddModuler("mysql", Moduler{})
+	helper.Registry.AddModuler("mysql", New)
+}
+
+// New creates new instance of Moduler
+func New() helper.Moduler {
+	return &Moduler{}
 }
 
 type Moduler struct{}

metricbeat/module/redis/redis.go

@@ -12,7 +12,12 @@ import (
 )
 
 func init() {
-	helper.Registry.AddModuler("redis", Moduler{})
+	helper.Registry.AddModuler("redis", New)
+}
+
+// New creates new instance of Moduler
+func New() helper.Moduler {
+	return &Moduler{}
 }
 
 type Moduler struct{}