Refactor tests/common to use more composable blocks.

So that we are not doing `if err != nil { return nil, err}` all the time and such

Also move some tests around.This is mostly motivated by some known issues with the -cover flag (https://groups.google.com/forum/#!topic/golang-nuts/GBeHbrIOxU4/discussion)

beater/beater_test.go

@@ -92,7 +92,7 @@ func pluralize(entity string) string {
 	return entity + "s"
 }
 func createPayload(entitytype string, numEntities int) []byte {
-	data, err := tests.LoadValidDataAsInterface(entitytype)
+	data, err := tests.LoadValidData(entitytype)
 	if err != nil {
 		panic(err)
 	}

beater/handlers_test.go

@@ -17,7 +17,7 @@ import (
 )
 
 func TestDecode(t *testing.T) {
-	transactionBytes, err := tests.LoadValidData("transaction")
+	transactionBytes, err := tests.LoadValidDataAsBytes("transaction")
 	assert.Nil(t, err)
 	buffer := bytes.NewReader(transactionBytes)
 	var data map[string]interface{}

beater/server_test.go

@@ -233,8 +233,8 @@ func setupServer(t *testing.T, ssl *SSLConfig) (*http.Server, func()) {
 
 var noSSL *SSLConfig
 
-var testData []byte = func() []byte {
-	d, err := tests.LoadValidData("transaction")
+var testData = func() []byte {
+	d, err := tests.LoadValidDataAsBytes("transaction")
 	if err != nil {
 		panic(err)
 	}

processor/error/benchmark_test.go

@@ -9,7 +9,7 @@ import (
 func BenchmarkEventWithFileLoading(b *testing.B) {
 	processor := NewProcessor()
 	for i := 0; i < b.N; i++ {
-		data, _ := tests.LoadValidDataAsInterface("error")
+		data, _ := tests.LoadValidData("error")
 		err := processor.Validate(data)
 		if err != nil {
 			panic(err)
@@ -21,7 +21,7 @@ func BenchmarkEventWithFileLoading(b *testing.B) {
 
 func BenchmarkEventFileLoadingOnce(b *testing.B) {
 	processor := NewProcessor()
-	data, _ := tests.LoadValidDataAsInterface("error")
+	data, _ := tests.LoadValidData("error")
 	for i := 0; i < b.N; i++ {
 		err := processor.Validate(data)
 		if err != nil {

processor/error/package_tests/json_schema_test.go

@@ -48,3 +48,11 @@ func TestJsonSchemaKeywordLimitation(t *testing.T) {
 	)
 	tests.TestJsonSchemaKeywordLimitation(t, fieldsPaths, er.Schema(), exceptions)
 }
+
+func TestErrorPayloadSchema(t *testing.T) {
+	testData := []tests.SchemaTestData{
+		{File: "data/invalid/error_payload/no_service.json", Error: "missing properties: \"service\""},
+		{File: "data/invalid/error_payload/no_errors.json", Error: "missing properties: \"errors\""},
+	}
+	tests.TestDataAgainstProcessor(t, er.NewProcessor(), testData)
+}

processor/error/package_tests/processor_test.go

@@ -12,18 +12,18 @@ import (
 // ensure all valid documents pass through the whole validation and transformation process
 func TestProcessorOK(t *testing.T) {
 	requestInfo := []tests.RequestInfo{
-		{Name: "TestProcessErrorMinimalPayloadException", Path: "tests/data/valid/error/minimal_payload_exception.json"},
-		{Name: "TestProcessErrorMinimalPayloadLog", Path: "tests/data/valid/error/minimal_payload_log.json"},
-		{Name: "TestProcessErrorMinimalService", Path: "tests/data/valid/error/minimal_service.json"},
-		{Name: "TestProcessErrorFull", Path: "tests/data/valid/error/payload.json"},
-		{Name: "TestProcessErrorNullValues", Path: "tests/data/valid/error/null_values.json"},
+		{Name: "TestProcessErrorMinimalPayloadException", Path: "data/valid/error/minimal_payload_exception.json"},
+		{Name: "TestProcessErrorMinimalPayloadLog", Path: "data/valid/error/minimal_payload_log.json"},
+		{Name: "TestProcessErrorMinimalService", Path: "data/valid/error/minimal_service.json"},
+		{Name: "TestProcessErrorFull", Path: "data/valid/error/payload.json"},
+		{Name: "TestProcessErrorNullValues", Path: "data/valid/error/null_values.json"},
 	}
 	tests.TestProcessRequests(t, er.NewProcessor(), requestInfo, map[string]string{})
 }
 
 // ensure invalid documents fail the json schema validation already
 func TestProcessorFailedValidation(t *testing.T) {
-	data, err := tests.LoadInvalidDataAsInterface("error")
+	data, err := tests.LoadInvalidData("error")
 	assert.Nil(t, err)
 	err = er.NewProcessor().Validate(data)
 	assert.NotNil(t, err)

processor/error/payload.go

@@ -14,8 +14,8 @@ var (
 
 type payload struct {
 	Service m.Service
-	System *m.System
-	Events []Event `mapstructure:"errors"`
+	System  *m.System
+	Events  []Event `mapstructure:"errors"`
 }
 
 func (pa *payload) transform() []beat.Event {

processor/sourcemap/decoder_test.go

@@ -17,7 +17,7 @@ func TestDecodeSourcemapFormData(t *testing.T) {
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 
-	fileBytes, err := tests.LoadData("tests/data/valid/sourcemap/bundle.min.map")
+	fileBytes, err := tests.LoadDataAsBytes("data/valid/sourcemap/bundle.min.map")
 	assert.NoError(t, err)
 	part, err := writer.CreateFormFile("sourcemap", "bundle.min.map")
 	assert.NoError(t, err)

processor/sourcemap/package_tests/json_schema_test.go

@@ -18,3 +18,13 @@ func TestPayloadAttributesInSchema(t *testing.T) {
 			"sourcemap.mappings", "sourcemap.sourcesContent", "sourcemap.version"),
 		sourcemap.Schema())
 }
+
+func TestSourcemapPayloadSchema(t *testing.T) {
+	testData := []tests.SchemaTestData{
+		{File: "data/invalid/sourcemap/no_service_version.json", Error: "missing properties: \"service_version\""},
+		{File: "data/invalid/sourcemap/no_bundle_filepath.json", Error: "missing properties: \"bundle_filepath\""},
+		{File: "data/invalid/sourcemap/not_allowed_empty_values.json", Error: "length must be >= 1, but got 0"},
+		{File: "data/invalid/sourcemap/not_allowed_null_values.json", Error: "expected string, but got null"},
+	}
+	tests.TestDataAgainstProcessor(t, sourcemap.NewProcessor(), testData)
+}

processor/sourcemap/package_tests/processor_test.go

@@ -12,15 +12,15 @@ import (
 // ensure all valid documents pass through the whole validation and transformation process
 func TestSourcemapProcessorOK(t *testing.T) {
 	requestInfo := []tests.RequestInfo{
-		{Name: "TestProcessSourcemapFull", Path: "tests/data/valid/sourcemap/payload.json"},
-		{Name: "TestProcessSourcemapMinimalPayload", Path: "tests/data/valid/sourcemap/minimal_payload.json"},
+		{Name: "TestProcessSourcemapFull", Path: "data/valid/sourcemap/payload.json"},
+		{Name: "TestProcessSourcemapMinimalPayload", Path: "data/valid/sourcemap/minimal_payload.json"},
 	}
 	tests.TestProcessRequests(t, sourcemap.NewProcessor(), requestInfo, map[string]string{"@timestamp": "***IGNORED***"})
 }
 
 // ensure invalid documents fail the json schema validation already
 func TestSourcemapProcessorValidationFailed(t *testing.T) {
-	data, err := tests.LoadInvalidDataAsInterface("sourcemap")
+	data, err := tests.LoadInvalidData("sourcemap")
 	assert.Nil(t, err)
 	p := sourcemap.NewProcessor()
 	err = p.Validate(data)

processor/sourcemap/payload.go

@@ -13,8 +13,8 @@ import (
 var sourcemapCounter = monitoring.NewInt(sourcemapUploadMetrics, "counter")
 
 type payload struct {
-	ServiceName        string `mapstructure:"service_name"`
-	ServiceVersion     string `mapstructure:"service_version"`
+	ServiceName    string `mapstructure:"service_name"`
+	ServiceVersion string `mapstructure:"service_version"`
 	Sourcemap      common.MapStr
 	BundleFilepath string `mapstructure:"bundle_filepath"`
 }

processor/sourcemap/payload_test.go

@@ -33,7 +33,7 @@ func getStrSlice(data common.MapStr, key string) []string {
 
 func TestPayloadTransform(t *testing.T) {
 
-	data, err := tests.LoadValidDataAsInterface("sourcemap")
+	data, err := tests.LoadValidData("sourcemap")
 	assert.NoError(t, err)
 
 	rs, err := NewProcessor().Transform(data)
@@ -71,7 +71,7 @@ func TestPayloadTransform(t *testing.T) {
 }
 
 func TestParseSourcemaps(t *testing.T) {
-	fileBytes, err := tests.LoadData("tests/data/valid/sourcemap/bundle.min.map")
+	fileBytes, err := tests.LoadDataAsBytes("data/valid/sourcemap/bundle.min.map")
 	assert.NoError(t, err)
 	parser, err := s.Parse("", fileBytes)
 	assert.NoError(t, err)

processor/transaction/benchmark_test.go

@@ -9,7 +9,7 @@ import (
 func BenchmarkWithFileLoading(b *testing.B) {
 	processor := NewProcessor()
 	for i := 0; i < b.N; i++ {
-		data, _ := tests.LoadValidDataAsInterface("transaction")
+		data, _ := tests.LoadValidData("transaction")
 		err := processor.Validate(data)
 		if err != nil {
 			b.Fatalf("Error: %v", err)
@@ -20,7 +20,7 @@ func BenchmarkWithFileLoading(b *testing.B) {
 
 func BenchmarkTransactionFileLoadingOnce(b *testing.B) {
 	processor := NewProcessor()
-	data, _ := tests.LoadValidDataAsInterface("transaction")
+	data, _ := tests.LoadValidData("transaction")
 	for i := 0; i < b.N; i++ {
 		err := processor.Validate(data)
 		if err != nil {

processor/transaction/package_tests/json_schema_test.go

@@ -41,3 +41,11 @@ func TestJsonSchemaKeywordLimitation(t *testing.T) {
 	exceptions := set.New("processor.event", "processor.name", "context.service.name", "transaction.id", "listening")
 	tests.TestJsonSchemaKeywordLimitation(t, fieldsPaths, transaction.Schema(), exceptions)
 }
+
+func TestTransactionPayloadSchema(t *testing.T) {
+	testData := []tests.SchemaTestData{
+		{File: "data/invalid/transaction_payload/no_service.json", Error: "missing properties: \"service\""},
+		{File: "data/invalid/transaction_payload/no_transactions.json", Error: "minimum 1 items allowed"},
+	}
+	tests.TestDataAgainstProcessor(t, transaction.NewProcessor(), testData)
+}

processor/transaction/package_tests/processor_test.go

@@ -12,20 +12,20 @@ import (
 // ensure all valid documents pass through the whole validation and transformation process
 func TestTransactionProcessorOK(t *testing.T) {
 	requestInfo := []tests.RequestInfo{
-		{Name: "TestProcessTransactionFull", Path: "tests/data/valid/transaction/payload.json"},
-		{Name: "TestProcessTransactionNullValues", Path: "tests/data/valid/transaction/null_values.json"},
-		{Name: "TestProcessSystemNull", Path: "tests/data/valid/transaction/system_null.json"},
-		{Name: "TestProcessTransactionMinimalPayload", Path: "tests/data/valid/transaction/minimal_payload.json"},
-		{Name: "TestProcessTransactionMinimalSpan", Path: "tests/data/valid/transaction/minimal_span.json"},
-		{Name: "TestProcessTransactionMinimalService", Path: "tests/data/valid/transaction/minimal_service.json"},
-		{Name: "TestProcessTransactionEmpty", Path: "tests/data/valid/transaction/transaction_empty_values.json"},
+		{Name: "TestProcessTransactionFull", Path: "data/valid/transaction/payload.json"},
+		{Name: "TestProcessTransactionNullValues", Path: "data/valid/transaction/null_values.json"},
+		{Name: "TestProcessSystemNull", Path: "data/valid/transaction/system_null.json"},
+		{Name: "TestProcessTransactionMinimalPayload", Path: "data/valid/transaction/minimal_payload.json"},
+		{Name: "TestProcessTransactionMinimalSpan", Path: "data/valid/transaction/minimal_span.json"},
+		{Name: "TestProcessTransactionMinimalService", Path: "data/valid/transaction/minimal_service.json"},
+		{Name: "TestProcessTransactionEmpty", Path: "data/valid/transaction/transaction_empty_values.json"},
 	}
 	tests.TestProcessRequests(t, transaction.NewProcessor(), requestInfo, map[string]string{})
 }
 
 // ensure invalid documents fail the json schema validation already
 func TestTransactionProcessorValidationFailed(t *testing.T) {
-	data, err := tests.LoadInvalidDataAsInterface("transaction")
+	data, err := tests.LoadInvalidData("transaction")
 	assert.Nil(t, err)
 	p := transaction.NewProcessor()
 	err = p.Validate(data)

processor/transaction/payload.go

@@ -15,8 +15,8 @@ var (
 
 type payload struct {
 	Service m.Service
-	System *m.System
-	Events []Event `mapstructure:"transactions"`
+	System  *m.System
+	Events  []Event `mapstructure:"transactions"`
 }
 
 func (pa *payload) transform() []beat.Event {

script/output_data/output_data.go

@@ -22,7 +22,7 @@ func main() {
 
 func generate() error {
 	filename := "payload.json"
-	basepath := "tests/data/valid"
+	basePath := "data/valid"
 	outputPath := "docs/data/elasticsearch/"
 
 	var checked = map[string]struct{}{}
@@ -35,7 +35,7 @@ func generate() error {
 
 		p := mapping.ProcessorFactory()
 
-		data, err := tests.LoadDataAsInterface(filepath.Join(basepath, p.Name(), filename))
+		data, err := tests.LoadData(filepath.Join(basePath, p.Name(), filename))
 		if err != nil {
 			return err
 		}

tests/approvals.go

@@ -95,7 +95,7 @@ type RequestInfo struct {
 func TestProcessRequests(t *testing.T, p processor.Processor, requestInfo []RequestInfo, ignored map[string]string) {
 	assert := assert.New(t)
 	for _, info := range requestInfo {
-		data, err := LoadDataAsInterface(info.Path)
+		data, err := LoadData(info.Path)
 		assert.Nil(err)
 
 		err = p.Validate(data)

tests/common.go

@@ -8,62 +8,46 @@ import (
 	"runtime"
 )
 
-func LoadDataAsInterface(file string) (map[string]interface{}, error) {
-	bytes, _ := LoadData(file)
-	data := make(map[string]interface{})
-	err := json.Unmarshal(bytes, &data)
-	return data, err
-}
-
-func LoadData(file string) ([]byte, error) {
+func findFile(fileName string) (string, error) {
 	_, current, _, _ := runtime.Caller(0)
-	return ioutil.ReadFile(filepath.Join(filepath.Dir(current), "..", file))
+	return filepath.Join(filepath.Dir(current), fileName), nil
 }
 
-func LoadValidData(dataType string) ([]byte, error) {
-	path, err := buildPath(dataType, true)
+func readFile(filePath string, err error) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return ioutil.ReadFile(path)
+	return ioutil.ReadFile(filePath)
 }
 
-func LoadValidDataAsInterface(dataType string) (map[string]interface{}, error) {
-	path, err := buildPath(dataType, true)
-	if err != nil {
-		return nil, err
-	}
-	var data map[string]interface{}
-	unmarshalData(path, &data)
-	return data, nil
+func LoadData(fileName string) (map[string]interface{}, error) {
+	return unmarshalData(findFile(fileName))
 }
 
-func LoadInvalidDataAsInterface(dataType string) (map[string]interface{}, error) {
-	path, err := buildPath(dataType, false)
-	if err != nil {
-		return nil, err
-	}
-	var data map[string]interface{}
-	unmarshalData(path, &data)
-	return data, nil
+func LoadDataAsBytes(fileName string) ([]byte, error) {
+	return readFile(findFile(fileName))
 }
 
-func UnmarshalValidData(dataType string, data interface{}) error {
-	path, err := buildPath(dataType, true)
-	if err != nil {
-		return err
-	}
-	return unmarshalData(path, data)
+func LoadValidDataAsBytes(processorName string) ([]byte, error) {
+	return readFile(buildPath(processorName, true))
+}
+
+func LoadValidData(processorName string) (map[string]interface{}, error) {
+	return unmarshalData(buildPath(processorName, true))
+}
+
+func LoadInvalidData(processorName string) (map[string]interface{}, error) {
+	return unmarshalData(buildPath(processorName, false))
 }
 
-func buildPath(dataType string, validData bool) (string, error) {
+func buildPath(processorName string, validData bool) (string, error) {
 	valid := "valid"
 	if !validData {
 		valid = "invalid"
 	}
 
 	var file string
-	switch dataType {
+	switch processorName {
 	case "error":
 		if validData {
 			file = "error/payload.json"
@@ -83,19 +67,18 @@ func buildPath(dataType string, validData bool) (string, error) {
 			file = "sourcemap/no_service_version.json"
 		}
 	default:
-		return "", errors.New("data type not specified.")
+		return "", errors.New("data type not specified")
 	}
-	_, current, _, _ := runtime.Caller(0)
-	curDir := filepath.Dir(current)
-	return filepath.Join(curDir, "data", valid, file), nil
+	return findFile(filepath.Join("data", valid, file))
 }
 
-func unmarshalData(file string, data interface{}) error {
-	input, err := ioutil.ReadFile(file)
-	if err != nil {
-		return err
+func unmarshalData(filePath string, err error) (map[string]interface{}, error) {
+	var data map[string]interface{}
+	input, err := readFile(filePath, err)
+	if err == nil {
+		err = json.Unmarshal(input, &data)
 	}
-	return json.Unmarshal(input, &data)
+	return data, err
 }
 
 func StrConcat(pre string, post string, delimiter string) string {

tests/fields.go

@@ -69,7 +69,7 @@ func TestDocumentedFieldsInEvent(t *testing.T, fieldPaths []string, fn processor
 
 func fetchEventNames(fn processor.NewProcessor, blacklisted *set.Set) (*set.Set, error) {
 	p := fn()
-	data, _ := LoadValidDataAsInterface(p.Name())
+	data, _ := LoadValidData(p.Name())
 	err := p.Validate(data)
 	if err != nil {
 		return nil, err