add tests

Signed-off-by: alexferl <me@alexferl.com>

cmd/tinysyslogd/main.go

@@ -3,17 +3,18 @@ package main
 import (
 	"github.com/rs/zerolog/log"
 
-	"tinysyslog"
 	"tinysyslog/config"
+	"tinysyslog/server"
 )
 
 func main() {
-	c := config.NewConfig()
+	c := config.New()
 	c.BindFlags()
 
-	server := tinysyslog.NewServer()
-	err := server.Run()
+	s, err := server.New()
 	if err != nil {
 		log.Fatal().Err(err).Msg("failed staring server")
 	}
+
+	s.Run()
 }

config/config.go

@@ -3,6 +3,10 @@ package config
 import (
 	"fmt"
 
+	"tinysyslog/filters"
+	"tinysyslog/mutators"
+	"tinysyslog/sinks"
+
 	libConfig "github.com/alexferl/golib/config"
 	libLog "github.com/alexferl/golib/log"
 	"github.com/spf13/pflag"
@@ -58,8 +62,8 @@ type RegexFilter struct {
 	Regex string
 }
 
-// NewConfig creates a Config instance
-func NewConfig() *Config {
+// New creates a Config instance
+func New() *Config {
 	c := libConfig.New("TINYSYSLOG")
 	c.AppName = "tinysyslog"
 	c.EnvName = "PROD"
@@ -83,11 +87,11 @@ func NewConfig() *Config {
 		LogFile:     "stdout",
 		LogFormat:   "text",
 		LogLevel:    "info",
-		MutatorType: constants.MutatorText,
+		MutatorType: mutators.TextKind.String(),
 		RegexFilter: RegexFilter{
 			Regex: "",
 		},
-		SinkTypes:  []string{constants.SinkConsole},
+		SinkTypes:  []string{sinks.ConsoleKind.String()},
 		SocketType: "",
 	}
 }
@@ -124,14 +128,14 @@ const (
 func (c *Config) addFlags(fs *pflag.FlagSet) {
 	fs.StringVar(&c.BindAddr, BindAddr, c.BindAddr, "IP and port to listen on.")
 	fs.StringVar(&c.FilterType, Filter, c.FilterType,
-		fmt.Sprintf("Filter to filter logs with. Valid filters: %s", constants.Filters),
+		fmt.Sprintf("Filter to filter logs with. Valid filters: %s", filters.Kinds),
 	)
 	fs.StringVar(&c.RegexFilter.Regex, FilterRegex, c.RegexFilter.Regex, "Regex to filter with.")
 	fs.StringVar(&c.MutatorType, Mutator, c.MutatorType,
-		fmt.Sprintf("Mutator type to use. Valid mutators: %s", constants.Mutators),
+		fmt.Sprintf("Mutator type to use. Valid mutators: %s", mutators.Kinds),
 	)
 	fs.StringSliceVar(&c.SinkTypes, Sinks, c.SinkTypes,
-		fmt.Sprintf("Sinks to save syslogs to. Valid sinks: %s", constants.Sinks),
+		fmt.Sprintf("Sinks to save syslogs to. Valid sinks: %s", sinks.Kinds),
 	)
 	fs.StringVar(&c.ConsoleSink.Output, SinkConsoleOutput, c.ConsoleSink.Output,
 		fmt.Sprintf("Console to output to. Valid outputs: %s", constants.ConsoleOutputs))

constants/constants.go

@@ -1,26 +1,5 @@
 package constants
 
-const (
-	MutatorText = "text"
-	MutatorJSON = "json"
-)
-
-var Mutators = []string{MutatorText, MutatorJSON}
-
-const (
-	FilterRegex = "regex"
-)
-
-var Filters = []string{FilterRegex}
-
-const (
-	SinkConsole       = "console"
-	SinkElasticsearch = "elasticsearch"
-	SinkFilesystem    = "filesystem"
-)
-
-var Sinks = []string{SinkConsole, SinkElasticsearch, SinkFilesystem}
-
 const (
 	ConsoleStdOut = "stdout"
 	ConsoleStdErr = "stderr"

factories.go → factories/factories.go

@@ -1,4 +1,4 @@
-package tinysyslog
+package factories
 
 import (
 	"os"
@@ -14,53 +14,53 @@ import (
 	"tinysyslog/sinks"
 )
 
-// MutatorFactory creates a new object with mutators.Mutator interface
-func MutatorFactory() mutators.Mutator {
-	mutatorType := viper.GetString(config.Mutator)
+// Mutator creates a new object with mutators.Mutator interface
+func Mutator() mutators.Mutator {
+	mutator := viper.GetString(config.Mutator)
 
-	if mutatorType == constants.MutatorText {
-		log.Debug().Msgf("using mutator '%s'", mutatorType)
+	if mutator == mutators.TextKind.String() {
+		log.Debug().Msgf("using mutator '%s'", mutator)
 		return mutators.NewText()
 	}
 
-	if mutatorType == constants.MutatorJSON {
-		log.Debug().Msgf("using mutator '%s'", mutatorType)
+	if mutator == mutators.JSONKind.String() {
+		log.Debug().Msgf("using mutator '%s'", mutator)
 		return mutators.NewJSON()
 	}
 
-	log.Warn().Msgf("unknown mutator '%s'. Falling back to '%s'", mutatorType, constants.MutatorText)
+	log.Warn().Msgf("unknown mutator '%s'. Falling back to '%s'", mutator, mutators.TextKind)
 	return mutators.NewText()
 }
 
-// FilterFactory creates a new object with filters.Filter interface
-func FilterFactory() filters.Filter {
-	filterType := viper.GetString(config.Filter)
+// Filter creates a new object with filters.Filter interface
+func Filter() filters.Filter {
+	filter := viper.GetString(config.Filter)
 
-	if filterType == "" {
+	if filter == "" {
 		log.Debug().Msgf("using no filtering")
 		return filters.NewNoOp()
 	}
 
-	if filterType == constants.FilterRegex {
-		filter := viper.GetString(config.FilterRegex)
-		log.Debug().Msgf("using filter '%s' with regular expression '%s'", filterType, filter)
-		return filters.NewRegex(filter)
+	if filter == filters.RegexKind.String() {
+		regex := viper.GetString(config.FilterRegex)
+		log.Debug().Msgf("using regex '%s' with regular expression '%s'", filter, regex)
+		return filters.NewRegex(regex)
 	}
 
-	log.Warn().Msgf("unknown filter '%s', falling back to no filtering", filterType)
+	log.Warn().Msgf("unknown filter '%s', falling back to no filtering", filter)
 	return filters.NewNoOp()
 }
 
-// SinksFactory creates a new slice of objects with sinks.Sink interface
-func SinksFactory() []sinks.Sink {
-	sinkTypes := viper.GetStringSlice(config.Sinks)
+// Sinks creates a new slice of objects with sinks.Sink interface
+func Sinks() []sinks.Sink {
+	sinksSlice := viper.GetStringSlice(config.Sinks)
 	mutatorType := viper.GetString(config.Mutator)
 
 	var sinksList []sinks.Sink
 
-	for _, sink := range sinkTypes {
-		switch sink {
-		case constants.SinkConsole:
+	for _, s := range sinksSlice {
+		switch s {
+		case sinks.ConsoleKind.String():
 			cOutput := viper.GetString(config.SinkConsoleOutput)
 			var stdOutput *os.File
 
@@ -71,12 +71,12 @@ func SinksFactory() []sinks.Sink {
 			} else {
 				log.Warn().Msgf("unknown console output '%s', falling back to '%s'", cOutput, constants.ConsoleStdOut)
 			}
-			log.Debug().Msgf("adding sink '%s'", sink)
+			log.Debug().Msgf("adding sink '%s'", s)
 			c := sinks.NewConsole(stdOutput)
 			sinksList = append(sinksList, c)
-		case constants.SinkElasticsearch:
-			if mutatorType != constants.MutatorJSON {
-				log.Panic().Msgf("mutator must be '%s' when using '%s' sink", constants.MutatorJSON, constants.SinkElasticsearch)
+		case sinks.ElasticsearchKind.String():
+			if mutatorType != mutators.JSONKind.String() {
+				log.Panic().Msgf("mutator must be '%s' when using '%s' sink", mutators.JSONKind, sinks.ElasticsearchKind)
 			}
 
 			cfg := sinks.ElasticsearchConfig{
@@ -90,20 +90,20 @@ func SinksFactory() []sinks.Sink {
 				ServiceToken: viper.GetString(config.SinkElasticsearchServiceToken),
 			}
 
-			log.Debug().Msgf("adding sink '%s'", sink)
+			log.Debug().Msgf("adding sink '%s'", s)
 			es := sinks.NewElasticsearch(cfg)
 			sinksList = append(sinksList, es)
-		case constants.SinkFilesystem:
+		case sinks.FilesystemKind.String():
 			fsFilename := viper.GetString(config.SinkFilesystemFilename)
 			fsMaxAge := viper.GetInt(config.SinkFilesystemMaxAge)
 			fsMaxBackups := viper.GetInt(config.SinkFilesystemMaxBackups)
 			fsMaxSize := viper.GetInt(config.SinkFilesystemMaxSize)
 
-			log.Debug().Msgf("adding sink '%s'", sink)
+			log.Debug().Msgf("adding sink '%s'", s)
 			fs := sinks.NewFilesystem(fsFilename, fsMaxAge, fsMaxBackups, fsMaxSize)
 			sinksList = append(sinksList, fs)
 		default:
-			log.Warn().Msgf("unknown sink '%s'.", sink)
+			log.Warn().Msgf("unknown sink '%s'.", s)
 		}
 	}
 	return sinksList

factories/factories_test.go

@@ -0,0 +1,26 @@
+package factories
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"tinysyslog/filters"
+	"tinysyslog/mutators"
+	"tinysyslog/sinks"
+)
+
+func TestMutator(t *testing.T) {
+	m := Mutator()
+	assert.Equal(t, mutators.TextKind, m.GetKind())
+}
+
+func TestFilter(t *testing.T) {
+	f := Filter()
+	assert.Equal(t, filters.NoOpKind, f.GetKind())
+}
+
+func TestSinks(t *testing.T) {
+	s := Sinks()
+	assert.Equal(t, []sinks.Sink(nil), s)
+}

filters/interface.go

@@ -1,6 +1,20 @@
 package filters
 
+type Kind int8
+
+const (
+	NoOpKind Kind = iota + 1
+	RegexKind
+)
+
+func (k Kind) String() string {
+	return [...]string{"noop", "regex"}[k-1]
+}
+
+var Kinds = []string{NoOpKind.String(), RegexKind.String()}
+
 // Filter is a common interface for all filters
 type Filter interface {
 	Filter(string) (string, error)
+	GetKind() Kind
 }

filters/noop.go

@@ -1,14 +1,20 @@
 package filters
 
 // NoOp represents a no operation filter
-type NoOp struct{}
+type NoOp struct {
+	kind Kind
+}
 
 // NewNoOp creates a NoOp instance
 func NewNoOp() Filter {
-	return Filter(&NoOp{})
+	return Filter(&NoOp{kind: NoOpKind})
 }
 
 // Filter filters a log entry
 func (n *NoOp) Filter(data string) (string, error) {
 	return data, nil
 }
+
+func (n *NoOp) GetKind() Kind {
+	return n.kind
+}

filters/noop_test.go

@@ -13,4 +13,5 @@ func TestNoOp(t *testing.T) {
 	s, err := f.Filter(msg)
 	assert.NoError(t, err)
 	assert.Equal(t, msg, s)
+	assert.Equal(t, NoOpKind, f.GetKind())
 }

filters/regex.go

@@ -7,11 +7,12 @@ import (
 // Regex represents a regex filter
 type Regex struct {
 	regex string
+	kind  Kind
 }
 
 // NewRegex creates a Regex instance
 func NewRegex(s string) Filter {
-	return Filter(&Regex{regex: s})
+	return Filter(&Regex{regex: s, kind: RegexKind})
 }
 
 // Filter filters a log entry
@@ -28,3 +29,7 @@ func (r *Regex) Filter(data string) (string, error) {
 	}
 	return data, nil
 }
+
+func (r *Regex) GetKind() Kind {
+	return r.kind
+}

filters/regex_test.go

@@ -25,6 +25,7 @@ func TestRegex(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			f := NewRegex(tc.re)
 			s, err := f.Filter(msg)
+			assert.Equal(t, RegexKind, f.GetKind())
 			if tc.err {
 				assert.Error(t, err)
 			} else {