add tests

Signed-off-by: alexferl <[email protected]>

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 {