Bump test coverage (#53)

* Test graph output

* Add entry.Read tests

* Add tests for entry.Parent and entry.Child

* Add parser_regex tests

* Add tests for errors

* Add test for google cloud output

* Add tests for TCP input plugin

* Add TCP and UDP tests

* Run tests in parallel and decrease polling rate for performance

* Add basic router test

* Add simple tests for generate_input

* Add coverpkg argument to tests

* Add basic syslog tests

* Add basic time parser and noop tests

* Move credentials parsing into Start()

* Remove traces of mapstructure

* Add basic timestamp plugin tests

* Log unexpected message

Author: camdencheek

.circleci/config.yml

@@ -39,7 +39,7 @@ jobs:
       - run:
           name: Unit tests
           command: |
-            go test -race -v -coverprofile=c.out ./...
+            go test -race -v -coverprofile=c.out -coverpkg ./... ./...
             ./cc-test-reporter after-build --coverage-input-type gocov -p github.com/bluemedora/bplogagent/
 
   test-macos:

.gitignore

@@ -1,3 +1,4 @@
 dev/*
 .DS_Store
-tmp/*
+tmp/*
+coverage.txt

commands/graph.go

@@ -16,7 +16,16 @@ type GraphFlags struct {
 	*RootFlags
 }
 
-func runGraph(command *cobra.Command, args []string, flags *GraphFlags) error {
+func NewGraphCommand(rootFlags *RootFlags) *cobra.Command {
+	return &cobra.Command{
+		Use:   "graph",
+		Args:  cobra.NoArgs,
+		Short: "Export a dot-formatted representation of the plugin graph",
+		Run:   func(command *cobra.Command, args []string) { runGraph(command, args, rootFlags) },
+	}
+}
+
+func runGraph(command *cobra.Command, args []string, flags *RootFlags) error {
 	var logger *zap.SugaredLogger
 	if flags.Debug {
 		logger = newDefaultLoggerAt(zapcore.DebugLevel)

commands/graph_test.go

@@ -0,0 +1,56 @@
+package commands
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+)
+
+func ExampleGraph() {
+	config := []byte(`
+plugins:
+  - id: generate
+    type: generate_input
+    output: json_parser
+    record:
+      test: value
+
+  - id: json_parser
+    type: json_parser
+    output: google_cloud
+
+  - id: google_cloud
+    project_id: testproject
+    type: google_cloud_output
+`)
+	tempDir, err := ioutil.TempDir("", "")
+	if err != nil {
+		panic(err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	configPath := filepath.Join(tempDir, "config.yaml")
+	err = ioutil.WriteFile(configPath, config, 0666)
+	if err != nil {
+		panic(err)
+	}
+
+	rootFlags := &RootFlags{
+		ConfigFiles: []string{configPath},
+	}
+	graphCmd := NewGraphCommand(rootFlags)
+	graphCmd.Execute()
+
+	// Output:
+	// strict digraph G {
+	//  // Node definitions.
+	//  generate;
+	//  json_parser;
+	//  google_cloud;
+	//
+	//  // Edge definitions.
+	//  generate -> json_parser;
+	//  json_parser -> google_cloud;
+	// }
+
+}

commands/root.go

@@ -58,17 +58,7 @@ func NewRootCmd() *cobra.Command {
 	rootFlagSet.DurationVar(&rootFlags.MemProfileDelay, "mem_profile_delay", 10*time.Second, "time to wait before writing a memory profile")
 	rootFlagSet.MarkHidden("mem_profile_delay")
 
-	graphFlags := &GraphFlags{
-		RootFlags: rootFlags,
-	}
-
-	graph := &cobra.Command{
-		Use:   "graph",
-		Args:  cobra.NoArgs,
-		Short: "Export a dot-formatted representation of the plugin graph",
-		Run:   func(command *cobra.Command, args []string) { runGraph(command, args, graphFlags) },
-	}
-
+	graph := NewGraphCommand(rootFlags)
 	root.AddCommand(graph)
 
 	return root

config/config.go

@@ -10,8 +10,8 @@ import (
 )
 
 type Config struct {
-	Plugins      []plugin.Config `mapstructure:"plugins"       json:"plugins"                 yaml:"plugins"`
-	DatabaseFile string          `mapstructure:"database_file" json:"database_file,omitempty" yaml:"database_file,omitempty"`
+	Plugins      []plugin.Config `json:"plugins"                 yaml:"plugins"`
+	DatabaseFile string          `json:"database_file,omitempty" yaml:"database_file,omitempty"`
 }
 
 func NewConfig() *Config {
@@ -20,8 +20,6 @@ func NewConfig() *Config {
 	}
 }
 
-var DecodeHookFunc = plugin.ConfigDecoder
-
 func ReadConfigsFromGlobs(globs []string) (*Config, error) {
 	paths := make([]string, 0, len(globs))
 	for _, glob := range globs {

config/config_test.go

@@ -244,35 +244,30 @@ plugins:
 		globs                []string
 		expectedPluginIDs    []string
 		expectedDatabaseFile string
-		expectedError        require.ErrorAssertionFunc
 	}{
 		{
 			"multiple inputs",
 			[]string{"file1", "file2", "output1"},
 			[]string{"fileinput1", "fileinput2", "output1"},
 			"test2.db",
-			require.NoError,
 		},
 		{
 			"single input",
 			[]string{"file1", "output1"},
 			[]string{"fileinput1", "output1"},
 			"test1.db",
-			require.NoError,
 		},
 		{
 			"globbed inputs",
 			[]string{"file*", "output1"},
 			[]string{"fileinput1", "fileinput2", "output1"},
 			"test2.db", // because glob returns in lexicographical order
-			require.NoError,
 		},
 		{
 			"globbed all",
 			[]string{"*"},
 			[]string{"fileinput1", "fileinput2", "output1"},
 			"test2.db", // because glob returns in lexicographical order
-			require.NoError,
 		},
 	}
 
@@ -294,7 +289,7 @@ plugins:
 				globs[i] = filepath.Join(dir, glob)
 			}
 			cfg, err := ReadConfigsFromGlobs(globs)
-			tc.expectedError(t, err)
+			require.NoError(t, err)
 
 			// Pull out the plugin IDs from the unmarshaled plugins
 			pluginIDs := make([]string, len(cfg.Plugins))
@@ -306,5 +301,4 @@ plugins:
 			require.ElementsMatch(t, tc.expectedPluginIDs, pluginIDs)
 		})
 	}
-
 }

entry/entry_test.go

@@ -1 +1,115 @@
 package entry
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestRead(t *testing.T) {
+	testEntry := &Entry{
+		Record: map[string]interface{}{
+			"string_field": "string_val",
+			"map_string_interface_field": map[string]interface{}{
+				"nested": "interface_val",
+			},
+			"map_string_interface_nonstring_field": map[string]interface{}{
+				"nested": 111,
+			},
+			"map_string_string_field": map[string]string{
+				"nested": "string_val",
+			},
+			"map_interface_interface_field": map[interface{}]interface{}{
+				"nested": "interface_val",
+			},
+			"map_interface_interface_nonstring_key_field": map[interface{}]interface{}{
+				100: "interface_val",
+			},
+			"map_interface_interface_nonstring_value_field": map[interface{}]interface{}{
+				"nested": 100,
+			},
+		},
+	}
+
+	t.Run("field not exist error", func(t *testing.T) {
+		var s string
+		err := testEntry.Read(Field{[]string{"nonexistant_field"}}, &s)
+		require.Error(t, err)
+	})
+
+	t.Run("unsupported type error", func(t *testing.T) {
+		var s **string
+		err := testEntry.Read(Field{[]string{"string_field"}}, &s)
+		require.Error(t, err)
+	})
+
+	t.Run("string", func(t *testing.T) {
+		var s string
+		err := testEntry.Read(Field{[]string{"string_field"}}, &s)
+		require.NoError(t, err)
+
+		require.Equal(t, "string_val", s)
+	})
+
+	t.Run("string error", func(t *testing.T) {
+		var s string
+		err := testEntry.Read(Field{[]string{"map_string_interface_field"}}, &s)
+		require.Error(t, err)
+	})
+
+	t.Run("map[string]interface{}", func(t *testing.T) {
+		var m map[string]interface{}
+		err := testEntry.Read(Field{[]string{"map_string_interface_field"}}, &m)
+		require.NoError(t, err)
+
+		require.Equal(t, map[string]interface{}{"nested": "interface_val"}, m)
+	})
+
+	t.Run("map[string]interface{} error", func(t *testing.T) {
+		var m map[string]interface{}
+		err := testEntry.Read(Field{[]string{"string_field"}}, &m)
+		require.Error(t, err)
+	})
+
+	t.Run("map[string]string from map[string]interface{}", func(t *testing.T) {
+		var m map[string]string
+		err := testEntry.Read(Field{[]string{"map_string_interface_field"}}, &m)
+		require.NoError(t, err)
+
+		require.Equal(t, map[string]string{"nested": "interface_val"}, m)
+	})
+
+	t.Run("map[string]string from map[string]interface{} err", func(t *testing.T) {
+		var m map[string]string
+		err := testEntry.Read(Field{[]string{"map_string_interface_nonstring_field"}}, &m)
+		require.Error(t, err)
+	})
+
+	t.Run("map[string]string from map[interface{}]interface{}", func(t *testing.T) {
+		var m map[string]string
+		err := testEntry.Read(Field{[]string{"map_interface_interface_field"}}, &m)
+		require.NoError(t, err)
+
+		require.Equal(t, map[string]string{"nested": "interface_val"}, m)
+	})
+
+	t.Run("map[string]string from map[interface{}]interface{} nonstring key error", func(t *testing.T) {
+		var m map[string]string
+		err := testEntry.Read(Field{[]string{"map_interface_interface_nonstring_key_field"}}, &m)
+		require.Error(t, err)
+	})
+
+	t.Run("map[string]string from map[interface{}]interface{} nonstring value error", func(t *testing.T) {
+		var m map[string]string
+		err := testEntry.Read(Field{[]string{"map_interface_interface_nonstring_value_field"}}, &m)
+		require.Error(t, err)
+	})
+
+	t.Run("interface{} from any", func(t *testing.T) {
+		var i interface{}
+		err := testEntry.Read(Field{[]string{"map_interface_interface_field"}}, &i)
+		require.NoError(t, err)
+
+		require.Equal(t, map[interface{}]interface{}{"nested": "interface_val"}, i)
+	})
+}

entry/field.go

@@ -3,11 +3,7 @@ package entry
 import (
 	"encoding/json"
 	"fmt"
-	"reflect"
 	"strings"
-
-	"github.com/bluemedora/bplogagent/errors"
-	"github.com/mitchellh/mapstructure"
 )
 
 // Field represents a potential field on an entry's record.
@@ -229,19 +225,3 @@ func NewField(keys ...string) Field {
 		Keys: keys,
 	}
 }
-
-// FieldDecoder is a custom decoder hook used by mapstructure to decode fields.
-var FieldDecoder mapstructure.DecodeHookFunc = func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
-	if t.String() != "entry.Field" {
-		return data, nil
-	}
-
-	if reflect.TypeOf(string("")) == f {
-		return fromJSONDot(data.(string)), nil
-	}
-
-	return nil, errors.NewError(
-		"failed to unmarshal field from type",
-		"ensure that all fields are encoded as strings",
-		"type", f.String())
-}